Ассемблер примеры программ: Программирование на Ассемблере для начинающих с примерами программ

Простая программа на ассемблере x86: Решето Эратосфена / Хабр

Содержание

Вступительное слово

По своей профессии я не сталкиваюсь с низкоуровневым программированием: занимаюсь программированием на скриптовых языках. Но поскольку душа требует разнообразия, расширения горизонтов знаний или просто понимания, как работает машина на низком уровне, я занимаюсь программированием на языках, отличающихся от тех, с помощью которых зарабатываю деньги – такое у меня хобби.

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

До ее написания я сформулировал такие требования к будущей программе:

  • Моя программа не должна быть программой под DOS. Слишком много примеров ориентировано на нее в связи с простым API. Моя программа обязательно должна была запускаться на современных ОС.
  • Программа должна использовать кучу – получать в свое распоряжение динамически распределяемую память.
  • Чтобы не быть слишком сложной, программа должна работать с целыми беззнаковыми числами без использования переносов.

Задачей для своей программы я выбрал поиск простых чисел с помощью Решета Эратосфена. В качестве ассемблера я выбрал nasm.

Код я писал с упором больше на стиль и понятность, чем на скорость его выполнения. К примеру, обнуление регистра я проводил не с помощью xor eax, eax, а с помощью mov eax, 0 в связи с более подходящей семантикой инструкции. Я решил, что поскольку программа преследует исключительно учебные цели, можно распоясаться и заниматься погоней за стилем кода в ассемблере.

Итак, посмотрим, что получилось.

С чего начать?

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

Так же встает вопрос, каким образом на таком низком уровне реализуется обмен данными между внутренним миром программы и внешней средой. Тут на сцену выходит API операционной системы. В DOS, как уже было упомянуто, интерфейс был достаточно простой. К примеру, программа «Hello, world» выглядела так:

SECTION .text
    org 0x100

    mov ah, 0x9
    mov dx, hello
    int 0x21
    
    mov ax, 0x4c00
    int 0x21

SECTION .data
    hello: db "Hello, world!", 0xD, 0xA, '$'

В Windows же для этих целей используется Win32 API, соответственно, программа должна использовать методы соответствующих библиотек:

%include "win32n.inc"

extern MessageBoxA
import MessageBoxA user32.dll
extern ExitProcess
import ExitProcess kernel32.dll

SECTION code use32 class=code
    ..start:

    push UINT MB_OK
    push LPCTSTR window_title
    push LPCTSTR banner
    push HWND NULL
    call [MessageBoxA]

    push UINT NULL
    call [ExitProcess]

SECTION data use32 class=data
    banner: db "Hello, world!", 0xD, 0xA, 0
    window_title: db "Hello", 0

Здесь используется файл win32n.inc, где определены макросы, сокращающие код для работы с Win32 API.

Я решил не использовать напрямую API ОС и выбрал путь использования функций из библиотеки Си. Так же это открыло возможность компиляции программы в Linux (и, скорее всего, в других ОС) – не слишком большое и нужное этой программе достижение, но приятное достижение.

Вызов подпрограмм

Потребность вызывать подпрограммы влечет за собой несколько тем для изучения: организация подпрограмм, передача аргументов, создание стекового кадра, работа с локальными переменными.

Подпрограммы представляют собой метку, по которой располагается код. Заканчивается подпрограмма инструкцией ret. К примеру, вот такая подпрограмма в DOS выводит в консоль строку «Hello, world»:

print_hello:
    mov ah, 0x9
    mov dx, hello
    int 0x21
    ret

Для ее вызова нужно было бы использовать инструкцию call:

call print_hello

Для себя я решил передавать аргументы подпрограммам через регистры и указывать в комментариях, в каких регистрах какие аргументы должны быть, но в языках высокого уровня аргументы передаются через стек. К примеру, вот так вызывается функция printf из библиотеки Си:

push hello
call _printf
add esp, 4

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

При входе в подпрограмму необходимо создать новый стековый кадр. Делается это следующим образом:

print_hello:
    push ebp ;сохраняем указатель начала стекового кадра на стеке
    mov ebp, esp ;теперь началом кадра является вершина предыдущего

Соответственно, перед выходом нужно восстановить прежнее состояние стека:

    mov esp, ebp
    pop ebp
    ret

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

print_hello:
    push ebp
    mov ebp, esp
    sub esp, 8 ;опускаем указатель вершины стека на 8 байт, чтобы выделить память

Так же архитектура x86 предоставляет специальные инструкции, с помощью которых можно более лаконично реализовать эти действия:

print_hello:
    enter 8, 0 ;создать новый кадр, выделить 8 байт для локальных переменных

    leave ;восстановить стек
    ret

Второй параметр инструкции enter – уровень вложенности подпрограммы. Он нужен для линковки с языками высокого уровня, поддерживающими такую методику организации подпрограмм. В нашем случае это значение можно оставить нулевым.

Непосредственно программа

Проект содержит такие файлы:
  • main.asm – главный файл,
  • functions.asm – подпрограммы,
  • string_constants.asm – определения строковых констант,
  • Makefile – сценарий сборки

Рассмотрим код основного файла:main.asm
%define SUCCESS 0
%define MIN_MAX_NUMBER 3
%define MAX_MAX_NUMBER 4294967294

global _main
extern _printf
extern _scanf
extern _malloc
extern _free

SECTION .text
_main:
	enter 0, 0
	
	;ввод максимального числа
	call input_max_number
	cmp edx, SUCCESS
	jne .custom_exit
	mov [max_number], eax
	
	;выделяем память для массива флагов
	mov eax, [max_number]
	call allocate_flags_memory
	cmp edx, SUCCESS
	jne .custom_exit
	mov [primes_pointer], eax
	
	;отсеять составные числа
	mov eax, [primes_pointer]
	mov ebx, [max_number]
	call find_primes_with_eratosthenes_sieve
	
	;вывести числа
	mov eax, [primes_pointer]
	mov ebx, [max_number]
	call print_primes
	
	;освободить память от массива флагов
	mov eax, [primes_pointer]
	call free_flags_memory
	
	;выход
	.success:
		push str_exit_success
		call _printf
		jmp .return
			
	.custom_exit:
		push edx
		call _printf
		
	.return:
		mov eax, SUCCESS
		leave
		ret
	
	%include "functions.asm"

SECTION .data
	max_number: dd 0
	primes_pointer: dd 0
	
	%include "string_constants.asm"


Видно, что программа поделена по смыслу на 5 блоков, оформленных в виде подпрограмм:
  1. input_max_number — с помощью консоли запрашивает у пользователя максимальное число, до которого производится поиск простых; во избежание ошибок значение ограничено константами MIN_MAX_NUMBER и MAX_MAX_NUMBER
  2. allocate_flags_memory — запросить у ОС выделение памяти для массива пометок чисел (простое/составное) в куче; в случае успеха возвращает указатель на выделенную память через регистр eax
  3. find_primes_with_eratosthenes_sieve — отсеять составные числа с помощью классического решета Эратосфена;
  4. print_primes — вывести в консоль список простых чисел;
  5. free_flags_memory — освободить память, выделенную для флагов

Для функций было условлено такое правило: значение возвращается через регистр eax, регистр edx содержит статус. В случае успеха он содержит значение SUCCESS, то есть, 0
, в случае неудачи — адрес строки с сообщением об ошибке, которое будет выведено пользователю.

Файл string_constants.asm содержит определение строковых переменных, значения которых, как намекает название файла, менять не предполагается. Только ради этих переменных было сделано исключение к правилу «не использовать глобальные переменные». Я так и не нашел более удобного способа доставлять строковые константы функциям ввода-вывода – подумывал даже записывать на стек непосредственно перед вызовами функций, но решил, что эта идея куда хуже идеи с глобальными переменными.

string_constants.asm
;подписи ввода-вывода, форматы
str_max_number_label: db "Max number (>=3): ", 0
str_max_number_input_format: db "%u", 0
str_max_number_output_format: db "Using max number %u", 0xD, 0xA, 0

str_print_primes_label: db "Primes:", 0xD, 0xA, 0
str_prime: db "%u", 0x9, 0
str_cr_lf: db 0xD, 0xA, 0
	
;сообщения выхода
str_exit_success: db "Success!", 0xD, 0xA, 0
str_error_max_num_too_little: db "Max number is too little!", 0xD, 0xA, 0
str_error_max_num_too_big: db "Max number is too big!", 0xD, 0xA, 0
str_error_malloc_failed: db "Can't allocate memory!", 0xD, 0xA, 0


Для сборки применяется такой сценарий:Makefile
ifdef SystemRoot
   format = win32
   rm = del
   ext = .exe
else
   format = elf
   rm = rm -f
   ext = 
endif

all: primes.o
	gcc primes.o -o primes$(ext)
	$(rm) primes.o

primes.o:
	nasm -f $(format) main.asm -o primes.o

Подпрограммы (функции)

input_max_number

Код подпрограммы
; Ввести максимальное число
; Результат: EAX - максимальное число
input_max_number:	
	;создать стек-фрейм,
	;4 байта для локальных переменных
	enter 4, 1

	;показываем подпись
	push str_max_number_label ;см. string_constants.asm
	call _printf
	add esp, 4

	;вызываем scanf
	mov eax, ebp
	sub eax, 4
	
	push eax
	push str_max_number_input_format ;см. string_constants.asm
	call _scanf
	add esp, 8
	
	mov eax, [ebp-4]

	;проверка
	cmp eax, MIN_MAX_NUMBER
	jb .number_too_little
	cmp eax, MAX_MAX_NUMBER
	ja .number_too_big
	jmp .success

	;выход
	.number_too_little:
		mov edx, str_error_max_num_too_little ;см. string_constants.asm
		jmp .return	
		
	.number_too_big:
		mov edx, str_error_max_num_too_big ;см. string_constants.asm
		jmp .return	

	.success:
		push eax
		push str_max_number_output_format ;см. string_constants.asm
		call _printf
		add esp, 4
		pop eax
		mov edx, SUCCESS
	
	.return:
		leave
		ret


Подпрограмма призвана ввести в программу максимальное число, до которого будет производиться поиск простых. Ключевым моментов тут является вызов функции scanf из библиотеки Си:
        mov eax, ebp
        sub eax, 4
	
        push eax
        push str_max_number_input_format ;см. string_constants.asm
        call _scanf
        add esp, 8
	
        mov eax, [ebp-4]

Таким образом, сначала в eax записывается адрес памяти на 4 байта ниже указателя базы стека. Это память, выделенная для локальных нужд подпрограммы. Указатель на эту память передается функции scanf как цель для записи данных, введенных с клавиатуры.

После вызова функции, в eax из памяти перемещается введенное значение.

allocate_flags_memory и free_flags_memory

Код подпрограмм
; Выделить память для массива флагов
; Аргумент: EAX - максимальное число
; Результат: EAX - указатель на память
allocate_flags_memory:
	enter 8, 1

	;выделить EAX+1 байт
	inc eax
	mov [ebp-4], eax
	
	push eax
	call _malloc
	add esp, 4
	
	;проверка
	cmp eax, 0
	je .fail
	mov [ebp-8], eax
	
	;инициализация
	mov byte [eax], 0
	
	cld
	mov edi, eax
	inc edi
	mov edx, [ebp-4]
	add edx, eax
	
	mov al, 1
	.write_true:
		stosb
		cmp edi, edx
		jb .write_true
	
	;выход
	mov eax, [ebp-8]
	jmp .success
	
	.fail:
		mov edx, str_error_malloc_failed ;см. string_constants.asm
		jmp .return
	
	.success:
		mov edx, SUCCESS
			
	.return:
		leave
		ret

; Освободить память от массива флагов
; Аргумент: EAX - указатель на память
free_flags_memory:
	enter 0, 1
	
	push eax
	call _free
	add esp, 4
	
	leave
	ret


Ключевыми местами этих подпрограмм являются вызовы функций malloc и free из библиотеки Си.

malloc в случае удачи возвращает через регистр eax адрес выделенной памяти, в случае неудачи этот регистр содержит 0. Это самое узкое место программы касательно максимального числа. 32 бит вполне достаточно для поиска простых чисел до 4 294 967 295, но выделить разом столько памяти не получится.

find_primes_with_eratosthenes_sieve

Код подпрограммы
;Найти простые числа с помощью решета Эратосфена ;Аргументы: EAX - указатель на массив флагов, EBX - максимальное число find_primes_with_eratosthenes_sieve: enter 8, 1 mov [ebp-4], eax add eax, ebx inc eax mov [ebp-8], eax ;вычеркиваем составные числа cld mov edx, 2 ;p = 2 mov ecx, 2 ;множитель с = 2 .strike_out_cycle: ;x = c*p mov eax, edx push edx mul ecx pop edx cmp eax, ebx jbe .strike_out_number jmp .increase_p .strike_out_number: mov edi, [ebp-4] add edi, eax mov byte [edi], 0 inc ecx ;c = c + 1 jmp .strike_out_cycle .increase_p: mov esi, [ebp-4] add esi, edx inc esi mov ecx, edx inc ecx .check_current_number: mov eax, ecx mul eax cmp eax, ebx ja .return lodsb inc ecx cmp al, 0 jne .new_p_found jmp .check_current_number .new_p_found: mov edx, ecx dec edx mov ecx, 2 jmp .strike_out_cycle .return: leave ret

Подпрограмма реализует классический алгоритм для вычеркивания составных чисел, решето Эратосфена, на языке ассемблера x86. Приятна тем, что не использует вызовы внешних функций и не требует обработки ошибок 🙂

print_primes

Код подпрограммы
; Вывести простые числа
; Параметры: EAX - указатель на массив флагов, EBX - максимальное число
print_primes:
	enter 12, 1
	mov [ebp-4], eax
	mov [ebp-8], ebx
	
	push str_print_primes_label
	call _printf
	add esp, 4
	
	cld
	mov esi, [ebp-4]
	mov edx, esi
	add edx, [ebp-8]
	inc edx
	
	mov [ebp-12], edx
	mov ecx, 0
	.print_cycle:
		lodsb
		cmp al, 0
		jne .print
		jmp .check_finish
		.print:
			push esi
			push ecx
			push str_prime ;см. string_constants.asm
			call _printf
			add esp, 4
			pop ecx
			pop esi
			mov edx, [ebp-12]
		.check_finish:
			inc ecx
			cmp esi, edx
			jb .print_cycle
			
	push str_cr_lf
	call _printf
	add esp, 4
			
	leave
	ret


Подпрограмма выводит в консоль простые числа. Ключевым моментом тут является вызов функции printf из библиотеки Си.
Заключение

Что ж, программа отвечает всем сформулированным требованиям и, кажется, проста для понимания. Хочется надеяться, кому-нибудь ее разбор поможет вникнуть в программирование на низком уровне и он получит от него такое же удовольствие, какое получил я.

Так же привожу полные исходники программы.

Могу так же привести интересный факт. Поскольку с детства нас учили, что программы на языке ассемблера выполняются быстрее, я решил сравнить скорость выполнения этой программы со скоростью программы на C++, которую я писал когда-то и которая искала простые числа с помощью Решета Аткина. Программа на С++, скомпилированная в Visual Studio с /O2 выполняла поиск до числа 230 примерно за 25 секунд на моей машине. Программа же на ассемблере показала 15 секунд с Решетом Эратосфена.

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

Полезные ссылки

  1. Список ресурсов для изучения ассемблера
  2. Организация памяти
  3. Решето Эратосфена
  4. Решето Аткина
  5. Стек
  6. Стековый кадр

Готовые программы Assembler. Примеры, задачи.

Готовые программы Assembler. Примеры, задачи.
  1. Главная
  2. Готовые программы Assembler
  • Замена одного символа на два
  • ASM + C++ Как вывести в консоль ?
  • Как прописывается 16-байтная переменная на masm32
  • NASM Крис касперски
  • Вычислить значение выражения: ((2*c)-(d/3)) / (b-(a/4))
  • Как на фасме объявить прототип пользовательской функции
  • [МС68HC11] Заполнить ячейки. Индексная адресация
  • MASM, cannot use 16-bit register with a 32-bit address
  • Вывести на экран символы, которые содержатся в обеих строках
  • Адресация информации
  • Перенести из массива в стек
  • Вычисление выражения по формуле
  • Что в данном фрагменте кода не соответствует соглашению stdcall?
  • Определить значения полей структуры по содержимому файла
  • Ошибка в программе по замене символов
  • Поменять числа местами
  • Реализация функции возведения в степень
  • Сортировка массива целых чисел по возрастанию
  • Записать алфавит в файл
  • Проверка байт статуса
  • Числа Фибоначчи
  • Ввести два 16-битовых целых числа А и В. Вычислить результат логического побитового исключающего ИЛИ чисел 10*
  • Сколько элементов строки превышают код введенного символа
  • Сложение нескольких десятичных чисел
  • Умножение/деление (сдвиг)
  • Первые n строк треугольника Паскаля (TASM)
  • Создания образа размещения программы в памяти
  • Обработка двумерного массива (матрицы): поиск минимума из положительных значений, новая матрица по условию
  • Обработка массива: поиск минимума, сортировка
  • Дизассемблирование команд с помощью W32Dasm
  • Найти максимальный элемент матрицы
  • _RUNDUDE.ASM
  • Матрица a не работает в другой прог
  • Инкремент, не работает флаг переполнения
  • Вычислить значение выражения
  • Зеркально отобразить байты из al в ah
  • Напечатать "да", если введенное число делится на 3 и на 2 одновременно...
  • Как вывести остаток от деления
  • Вычисление по формуле
  • Вычислить значение выражения
  • Организация программы
  • Ввести число в 16-ричном виде, вывести соответствующий ASCII символ
  • Программа вычисления выражения
  • Перепечатать заданный текст, удалив из него символы "b", непосредственно перед которыми следует цифра
  • [TASM] Магический квадрат (3х3)
  • Вывод элементов, находящихся после максимального элемента в массиве
  • Настройка DosBox
  • В цикле найти сумму целочисленного ряда
  • Циклы: определить сумму первых n чисел, кратных двум
  • Заполнение блока памяти из N слов рядом натуральных чисел

Ассемблер для начинающих / Хабр

В любом деле главное — начать. Или вот еще хорошая поговорка: «Начало — половина дела». Но иногда даже не знаешь как подступиться к интересующему вопросу. В связи с тем, что воспоминания мои еще свежи, спешу поделиться своими соображениями с интересующимися.

Скажу сразу, что лично я ассемблирую не под PC, а под микроконтроллеры. Но это не имеет большого значения, ибо (в отличие от микроконтроллеров AVR) система команд данных микроконтроллеров с PC крайне схожа. Да и, собственно говоря, ассемблер он и в Африке ассемблер.

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

Для начала успокою любознательных новобранцев: ассемблер — это совсем не сложно, вопреки стереотипному мнению. Просто он ближе к «земле», то бишь к архитектуре. На самом деле, он очень прост, если ухватить основную идею. В отличие от языков высокого уровня и разнообразных специализированных платформ для программирования (под всем перечисленным я понимаю всякое вроде C++, MatLAB и прочих подобных штук, где требуются программерские навыки), команд тут раз-два и обчелся. По началу даже, когда мне нужно было посчитать двойной интеграл, эта задача вызывала лишь недоумение: как при помощи такого скудного количества операций можно совершить подобную процедуру? Ведь образно говоря, на ассемблере можно разве что складывать, вычитать и сдвигать числа. Но с помощью ассемблера можно совершать сколь угодно сложные операции, а код будет выходить крайне лёгкий. Вот даже для примера, нужно вам зажечь светодиод, который подключен, например, к нулевому контакту порта номер 2, вы просто пишете:
bset P2.0
И, как говорится, никаких проблем. Нужно включить сразу штуки четыре, подключенных последовательно? Да запросто:
mov P2, #000fh
Да, тут я подразумеваю, что начинающий боец уже знаком хотя бы со системами счисления. Ну хотя бы с десятичной. 😉

Итак, для достижения успеха в деле ассемблирования, следует разбираться в архитектуре (в моем случае) микроконтроллера. Это раз.

Кстати, одно из больных мест в познании архитектуры — это организация памяти. Тут на Хабре я видела соответствующую статью: habrahabr.ru/blogs/programming/128991. Еще могу упомянуть ключевые болевые точки: прерывания. Штука не сложная, но по началу (почему-то) тяжелая для восприятия.

Если перед вами стоит сложная задача и вы даже не знаете как по началу к ней подступиться, лучше всего написать алгоритм. Это воистину спасает. А по началу, даже если программа совершенно не сложная, лучше всё же начать с алгоритма, ибо этот процесс помогает разложить всё в голове по местам. Возвращаясь к примеру с вычислением двойного интеграла по экспериментальным данным, обдумывала алгоритм я весь день, но зато потом программку по нему написала всего за 20 минут. Плюс алгоритм будет полезен при дальнейшей модернизации и/или эксплуатации программы, а то ассемблерный код, временами, если и будет понятен построчно, то чтобы разобраться в чем же общая идея, придется немало потрудиться.

Итак, второй ключ к успеху — подробно написанный и хорошо продуманный алгоритм. Настоятельно рекомендую не садиться сразу за аппарат и писать программу. Ничего дельного вы с ходу не напишете. Это два.

Собственно, хотелось бы как Фандорин написать: «Это т-т-три»… Но, боюсь, на этом пока можно остановиться. Хотя хотелось бы добавить еще несколько рекомендаций и пряников.

Подводя итог моему несколько сумбурному монологу, ключевые моменты в программировании на ассемблере — это знание архитектуры и связное построение мыслей. Конечно, не обязательно сразу с головой кидаться в штудировании литературы с описанием внутренностей того же PC, но общее представление (повторюсь, хотя бы для начала) будет очень нужно.

А теперь обещанные пряники! Вот я тут распинаюсь о каком-то непонятном ассемблере, а что же в нем, собственно говоря, хорошего? Да много всего! Во-первых, конечно, не нужно запоминать много команд, используемых библиотек и прочей сопутствующей дребедени. Всего парочка команд и, считайте, вы во всеоружии. Во-вторых, в связи с крайней близостью к машинным кодам, вы можете делать практически всё, что душе угодно (в отличие от тех же языков высокого уровня)! В-третьих, ассемблерный код, по причине максимальной лаконичности в формулировках, выполняется крайне быстро.

В общем, сплошные плюсы. На этой оптимистической ноте разрешите откланяться.

Ассемблер. Базовый синтаксис | Уроки Ассемблера

  Обновл. 29 Сен 2019  | 

Программы на ассемблере могут быть разделены на три секции:

   Секция data

   Секция bss

   Секция text

Секции ассемблера

Секция data используется для объявления инициализированных данных или констант. Данные в этой секции не могут быть изменены во время выполнения. Вы можете хранить константные значения и названия файлов в этой секции. Синтаксис объявления:

Секция bss используется для объявления переменных. Синтаксис объявления:

Секция text используется для хранения кода программы. Данная секция должна начинаться с объявления global_start, которое сообщает ядру, откуда нужно начинать выполнение программы. Синтаксис объявления:

section.text global _start _start:

section.text

   global _start

_start:

Комментарии

Комментарии в ассемблере должны начинаться с точки с запятой (;). Они могут содержать любой печатный символ, включая пробел. Комментарий может находиться как на отдельной строке:

; эта программа выводит сообщение на экран

; эта программа выводит сообщение на экран

Так и на строке со стейтментом:

add eax, ebx ; добавляет ebx к eax

add eax, ebx     ; добавляет ebx к eax

Стейтменты

В ассемблере есть три вида стейтментов:

   Выполняемые инструкции (или просто «инструкции»), которые сообщают процессору, что нужно делать. Каждая инструкция хранит в себе код операции (или ещё «опкод») и генерирует одну инструкцию на машинном языке.

   Директивы ассемблера, которые сообщают программе об аспектах компиляции. Они не генерируют инструкции на машинном языке.

   Макросы, которые являются простым механизмом вставки кода.

В ассемблере на одну строку приходится один стейтмент, который должен соответствовать следующему формату:

[метка] mnemonic [операнды] [; комментарий]

[метка]   mnemonic   [операнды]   [; комментарий]

Базовая инструкция состоит из названия инструкции (mnemonic) и операндов (они же «параметры»). Вот примеры типичных стейтментов ассемблера:

INC COUNT ; выполняем инкремент переменной памяти COUNT MOV TOTAL, 48 ; перемещаем значение 48 в переменную памяти TOTAL ADD AH, BH ; добавляем содержимое регистра BH к регистру AH AND MASK1, 128 ; выполняем операцию AND с переменной MASK1 и 128 ADD MARKS, 10 ; добавляем 10 к переменной MARKS MOV AL, 10 ; перемещаем значение 10 в регистр AL

INC COUNT        ; выполняем инкремент переменной памяти COUNT

 

MOV TOTAL, 48    ; перемещаем значение 48 в переменную памяти TOTAL

  

ADD AH, BH       ; добавляем содержимое регистра BH к регистру AH

  

AND MASK1, 128   ; выполняем операцию AND с переменной MASK1 и 128

  

ADD MARKS, 10    ; добавляем 10 к переменной MARKS

MOV AL, 10       ; перемещаем значение 10 в регистр AL

Первая программа

Следующая программа на языке ассемблера выведет строку Hello, world! на экран:

section .text global _start ; необходимо для линкера (ld) _start: ; сообщает линкеру стартовую точку mov edx,len ; длина строки mov ecx,msg ; строка mov ebx,1 ; дескриптор файла (stdout) mov eax,4 ; номер системного вызова (sys_write) int 0x80 ; вызов ядра mov eax,1 ; номер системного вызова (sys_exit) int 0x80 ; вызов ядра section .data msg db 'Hello, world!', 0xa ; содержимое строки для вывода len equ $ - msg ; длина строки

section .text

   global _start    ; необходимо для линкера (ld)

_start:             ; сообщает линкеру стартовую точку

   mov edx,len     ; длина строки

   mov ecx,msg     ; строка

   mov ebx,1       ; дескриптор файла (stdout)

   mov eax,4       ; номер системного вызова (sys_write)

   int 0x80        ; вызов ядра

   mov eax,1       ; номер системного вызова (sys_exit)

   int 0x80        ; вызов ядра

 

section .data

msg db 'Hello, world!', 0xa  ; содержимое строки для вывода

len equ $ - msg              ; длина строки

Результат выполнения программы выше:

Hello, world!

Сборка программ

Убедитесь, что у вас установлен NASM. Запишите вашу программу в текстовом редакторе и сохраните её как hello.asm. Затем:

   откройте терминал;

   убедитесь, что вы находитесь в той же директории, в которой вы сохранили hello.asm;

   чтобы собрать программу, введите команду nasm -f elf hello.asm;

   если не было ошибок, то создастся объектный файл вашей программы под названием hello.o;

   чтобы ваш объектный файл прошёл линкинг и создался исполняемый файл под названием hello, введите команду ld -m elf_i386 -s -o hello hello.o;

   запустите программу, написав команду ./hello.

Если всё прошло успешно, то вам выведется Hello, world!.

Если у вас нет возможности скомпилировать программу, например, у вас нет Linux и вы пока не хотите на него переходить, то можете использовать одну из следующих онлайн-IDE:

   TutorialsPoint

   JDoodle

Примечание: Запоминать две команды выше для сборки программы на ассемблере для некоторых может быть несколько затруднительно, поэтому вы можете написать скрипт для сборки программ на ассемблере. Для этого создайте файл под названием Makefile со следующим содержанием:

all: nasm –f elf $(source) ld –m elf_i386 –s –o $(source) $(source).o rm $(source).o

all:

    nasm –f elf $(source)

    ld –m elf_i386 –s –o $(source) $(source).o

    rm $(source).o

Для сборки hello.asm выполните следующие действия:

   откройте терминал;

   убедитесь, что вы находитесь в той же директории, в которой вы сохранили hello.asm и Makefile;

   введите команду make source=hello.


Оценить статью:

Загрузка...

Поделиться в социальных сетях:

Процедуры в ассемблере на примере простой программы ms-dos.
Процедуры в ассемблере

Процедуры в ассемблере.

Процедуры в ассемблере будут рассмотрены в четырёх статьях, в которых мы изучим общие понятия и определения процедур, использование стека для передачи параметров,  а также использование прерываний DOS — как разновидности функций ядра операционки (статьи 15-19: «Процедуры (функции)», «Стек», «Конвенции вызова функции», «Упрощаем вызов функции в TASM», «Прерывания DOS»).

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

Изучаем процедуры на примере goblin.com.

Пакет всего необходимого, включая исходники (DOS-1.rar) можно скачать с нашего сайта по ссылке.

Полный код нашей подопытной программы:

;goblin.asm .model tiny ; for СОМ .code ; code segment start org 100h ; offset in memory = 100h (for COM) start: main proc begin: mov ah,09h mov dx,offset prompt int 21h inpt: mov ah,01h int 21h cmp al,'m' je mode_man cmp al,'w' je mode_woman call goblin jmp begin mode_man: mov addrs,offset man; указатель на процедуру в addrs jmp cont mode_woman: mov addrs,offset woman; указатель на процедуру в addrs cont: call word ptr addrs; косвенный вызов процедуры mov ax,4c00h int 21h main endp man proc mov ah,09h mov dx,offset mes_man int 21h ret man endp woman proc mov ah,09h mov dx,offset mes_womn int 21h ret woman endp goblin proc mov ah,09h mov dx,offset mes_gobl int 21h ret goblin endp ;DATA addrs dw 0;for procedure adress prompt db 'Are you Man or Woman [m/w]? : $' mes_man db 0Dh,0Ah,"Hello, Strong Man!",0Dh,0Ah,'$' ; строка для вывода. Вместо ASCII смвола '$' можно написать машинный код 24h mes_womn db 0Dh,0Ah,"Hello, Beautyful Woman!",0Dh,0Ah,'$' ; строка для вывода mes_gobl db 0Dh,0Ah,"Hello, Strong and Beautyful GOBLIN!",0Dh,0Ah,24h ; строка для вывода. 24h = '$' . len = $ - mes_gobl end start

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

;goblin.asm

.model tiny ; for СОМ

.code ; code segment start

org 100h ; offset in memory = 100h (for COM)

 

start: main proc

begin:

mov ah,09h

mov dx,offset prompt

int 21h

inpt:

mov ah,01h

int 21h

cmp al,'m'

je mode_man

cmp al,'w'

je mode_woman

call goblin

jmp begin

mode_man:

mov addrs,offset man; указатель на процедуру в addrs

jmp cont

mode_woman:

mov addrs,offset woman; указатель на процедуру в addrs

cont:

call word ptr addrs; косвенный вызов процедуры

mov ax,4c00h

int 21h

main endp

 

man proc

mov ah,09h

mov dx,offset mes_man

int 21h

ret

man endp

 

woman proc

mov ah,09h

mov dx,offset mes_womn

int 21h

ret

woman endp

 

goblin proc

mov ah,09h

mov dx,offset mes_gobl

int 21h

ret

goblin endp

 

;DATA

addrs dw 0;for procedure adress

prompt db 'Are you Man or Woman [m/w]? : $'

mes_man db 0Dh,0Ah,"Hello, Strong Man!",0Dh,0Ah,'$' ; строка для вывода. Вместо ASCII смвола '$' можно написать машинный код 24h

mes_womn db 0Dh,0Ah,"Hello, Beautyful Woman!",0Dh,0Ah,'$' ; строка для вывода

mes_gobl db 0Dh,0Ah,"Hello, Strong and Beautyful GOBLIN!",0Dh,0Ah,24h ; строка для вывода. 24h = '$' .

len = $ - mes_gobl

end start

Goblin.com включает в себя несколько подпрограмм:

  • main proc
  • man proc
  • woman proc
  • goblin proc

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

Вызов процедуры в ассемблере.

Вызов процедуры в ассемблере осуществ

MASM, TASM, FASM, NASM под Windows и Linux / Хабр

Часть I
Часть II
Часть III

В данной статье я хочу рассмотреть вопросы, которые могут возникнуть у человека, приступившего к изучению ассемблера, связанные с установкой различных трансляторов и трансляцией программ под Windows и Linux, а также указать ссылки на ресурсы и книги, посвященные изучению данной темы.

MASM


Используется для создания драйверов под Windows.

По ссылке переходим на сайт и скачиваем пакет (masm32v11r.zip). После инсталляции программы на диске создается папка с нашим пакетом C:\masm32. Создадим программу prog11.asm, которая ничего не делает.
.586P
.model flat, stdcall 
_data segment 
_data ends
_text segment
start:
ret   
_text ends
end start

Произведём ассемблирование (трансляцию) файла prog11.asm, используя ассемблер с сайта masm32.


Ключ /coff используется здесь для трансляции 32-битных программ.
Линковка производится командой link /subsystem:windows prog11.obj (link /subsystem:console prog11.obj)

Как сказано в Википедии

MASM — один из немногих инструментов разработки Microsoft, для которых не было отдельных 16- и 32-битных версий.

Также ассемблер версии 6. можно взять на сайте Кипа Ирвина kipirvine.com/asm, автора книги «Язык ассемблера для процессоров Intel».

Кстати, вот ссылка на личный сайт Владислава Пирогова, автора книги “Ассемблер для Windows”.

MASM с сайта Microsoft

Далее скачаем MASM (версия 8.0) с сайта Microsoft по ссылке. Загруженный файл носит название «MASMsetup.exe». При запуске этого файла получаем сообщение -«Microsoft Visual C++ Express Edition 2005 required».

Открываем этот файл архиватором (например 7zip). Внутри видим файл setup.exe, извлекаем его, открываем архиватором. Внутри видим два файла vc_masm.msi,vc_masm1.cab. Извлекаем файл vc_masm1.cab, открываем архиватором. Внутри видим файл FL_ml_exe_____X86.3643236F_FC70_11D3_A536_0090278A1BB8. Переименовываем его в файл fl_ml.exe, далее, произведём ассемблирование файла prog11.asm, используя ассемблер fl_ml.exe.

MASM в Visual Studio

Также MASM можно найти в папке с Visual Studio (у меня VS 10) вот здесь: C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\ml.exe.

Для того, чтобы запустить на 32- или 64-разрядной системе и создавать программы, работающие как под 32-, так и под 64-разрядной Windows, подходит MASM32 (ml.exe, fl_ml.exe). Для того, чтобы работать на 32- и 64-разрядных системах и создавать программы, работающие под 64-разрядной Windows, но неработающие под 32-разрядной нужен ассемблер ml64.exe. Лежит в папке C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\amd64 и вот здесь — C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\x86_amd64.

TASM


Программный пакет компании Borland, предназначенный для разработки программ на языке ассемблера для архитектуры x86. В настоящее время Borland прекратила распространение своего ассемблера.

Скачать можно, например, здесь. Инсталлятора нет, просто извлекаем программу. Вот исходник из книги Питера Абеля (рис. 3.2) «Язык Ассемблера для IBM PC и программирования».

stacksg segment para stack 'stack'
    db 12 dup ('stackseg')
stacksg ends
codesg segment para 'code'
begin proc far
 assume ss:stacksg,cs:codesg,ds:nothing
 push ds
 sub ax,ax
 push ax
 mov ax, 0123h
 add ax, 0025h
 mov bx,ax
 add bx,ax
 mov cx,bx
 sub cx,ax
 sub ax,ax
 nop
 ret
begin endp
codesg ends
 end begin

Выполним ассемблирование (трансляцию) файла abel32.asm.

Корректность работы программы можно проверить, произведя линковку (tlink.exe) объектного файла и запустив полученный файл в отладчике.

Как было сказано выше, MASM можно использовать для работы с 16-битными программами. Выполним ассемблирование (трансляцию) программы abel32.asm с помощью ассемблера MASM:

Ключ /coff здесь не используется.
Линковка производится файлом link16.exe

FASM


В статье Криса Касперски «Сравнение ассемблерных трансляторов» написано, что «FASM — неординарный и весьма самобытный, но увы, игрушечный ассемблер. Пригоден для мелких задач типа „hello, world“, вирусов, демок и прочих произведений хакерского творчества.»

Скачаем FASM с официального сайта. Инсталлятора нет, просто извлекаем программу. Откроем fasm editor — C:\fasm\fasmw.exe. В папке C:\fasm\EXAMPLES\HELLO есть файл HELLO.asm.

include 'win32ax.inc' 
.code
  start:
 invoke    MessageBox,HWND_DESKTOP,"Hi! I'm the example program!",invoke GetCommandLine,MB_OK
    invoke    ExitProcess,0
.end start

Откроем файл HELLO.asm из fasmw.exe. Изменим строку include 'win32ax.inc' на строку include 'c:\fasm\INCLUDE\WIN32AX.INC'. Запускаем из меню Run → Run.

Вот ссылки на ресурсы, посвященные FASM:

→ FASM на Cyberforum'е
→ FASM на asmworld .com программы под Dos
→ Цикл статей «Ассемблер под Windows для чайников»
→ Сайт на narod'е

FASM в Linux

Для того, использовать FASM в Linux (у меня Ubuntu), скачаем соответствующий дистрибутив (fasm-1.71.60.tgz), распакуем его, в папке у нас будет бинарный файл fasm, копируем этот файл в /usr/local/bin для того, чтобы можно было запускать его из консоли, как любую другую команду.Выполним ассемблирование программы hello.asm из папки fasm/examples/elfexe/hello.asm.

Корректность работы программы можно проверить в отладчике.

Nasm


Nasm успешно конкурирует со стандартным в Linux- и многих других UNIX-системах ассемблером Gas.

Nasm в Linux можно установить его с помощью менеджера пакетов или из командной строки: в дистрибутиве Debian (Ubuntu) командой apt-get install nasm, в дистрибутивах Fedora, CentOS, RedHat командой yum install nasm.

Создадим программу, которая 5 раз выводит сообщение “Hello”. Пример взят из книги Андрея Викторовича Столярова “Программирование на языке ассемблера NASM для ОС UNIX”. Учебник, а также библиотека “stud_io.inc” есть на личном сайте автора.

%include "stud_io.inc"
global _start
section .text
_start: mov eax, 0
again:  PRINT "Hello"
PUTCHAR 10
inc eax
cmp eax, 5
jl again
FINISH

Выполним ассемблирование и линковку и запустим файл hello.asm.
$ nasm -f elf hello.asm
$ ld hello.o -o hello
$ ./hello

Для 64bit необходимо использовать команду nasm -f elf64 hello.asm

NASM для Windows

NASM для Windows можно установить, скачав соответствующий дистрибутив с соответствующего сайта.

Ассемблирование:
nasm -f bin имя_файла.asm -o имя_файла.com

Ссылки на ресурсы, посвященные Nasm:

→ Сайт А.В. Столярова
→ Сайт, на котором лежит электронный учебник (в архиве)
→ То же самое

AS


Стандартный ассемблер практически во всех разновидностях UNIX, в том числе Linux и BSD. Свободная версия этого ассемблера называется GAS (GNU assembler). Позволяет транслировать программы с помощью компилятора GCC.

Из учебников удалось найти только книгу на английском «Programming from the ground up». На русском удалось найти только одну главу из книги С. Зубкова «Assembler для DOS, Windows и UNIX».

Возьмем пример программы, которая ничего не делает, с сайта. Создадим программу gas.s

.section .text
   .globl _start
   _start:
      movl  $1, %eax
      movl  $2, %ebx
      int   $0x80

Выполним ассемблирование (трансляцию), линковку и запуск программы:
$ as -o gas.o gas.s
$ ld -o gas gas.o
$ ./gas

Если в данной программе изменить _start на main, то можно выполнить ассемблирование (трансляцию) и линковку компилятором gcc.
.section .text
   .globl main
   main:
      movl  $1, %eax
      movl  $2, %ebx
      int   $0x80

Выполним ассемблирование (трансляцию), линковку и запуск программы:
$ gcc gas.s -o gas
$ ./gas

Выводы: если вы изучаете программирование под Windows, то вы можете остановить свой выбор на Masm; Tasm больше не поддерживается, но для обучения по старым классическим учебникам подойдёт.
Под Linux Gas подойдет тем, кто использует GCC, а тем, кому не нравится синтаксис Gas, подойдёт Nasm.

P.S. Следующие две части, в целом, посвящены обработке строки в цикле.
P.P.S. Little Man Computer — учебная модель компьютера с ограниченым набором ассемблерных инструкций рассматривается в этой статье.

Assembler Linux / Песочница / Хабр

Компиляторы ассемблера в Linux

В Linux традиционно используется компилятор ассемблера GNU Assembler (GAS, вызываемый командой as), входящий в состав пакета GCC. Этот компилятор является кроссплатформенным, т. е. может компилировать программы, написанные на различных языках ассемблера для разных процессоров. Однако GAS использует синтаксис AT&T, а не Intel, поэтому его использование программистами, привыкшими к синтаксису Intel, вызывает некоторый дискомфорт.
Например программа, выводящая на экран сообщение «Hello, world!» (далее будем называть ее hello) выглядит следующим образом:

.section .data
msg:
.ascii "Hello, world!\n"
len = . - msg # символу len присваевается длина строки
.section .text
.global _start # точка входа в программу
_start:
movl $4, %eax # системный вызов № 4 — sys_write
movl $1, %ebx # поток № 1 — stdout
movl $msg, %ecx # указатель на выводимую строку
movl $len, %edx # длина строки
int $0x80 # вызов ядра
movl $1, %eax # системный вызов № 1 — sys_exit
xorl %ebx, %ebx # выход с кодом 0
int $0x80 # вызов ядра

Как видно из примера, различия видны как в синтаксисе команд, так и в синтаксисе директив ассемблера и комментариях.
В последних версиях GAS появилась возможность использования синтаксиса Intel для команд, но синтаксис директив и комментариев остается традиционным. Включение синтаксиса Intel осуществляется директивой .intel_syntax с параметром noprefix. При этом программа, приведенная выше изменится следующим образом:

.intel_syntax noprefix
.section .data
msg:
.ascii "Hello, world!\n"
len = . - msg # символу len присваевается длина строки
.section .text
.global _start # точка входа в программу
_start:
mov eax, 4 # системный вызов № 4 — sys_write
mov ebx, 1 # поток № 1 — stdout
mov ecx, OFFSET FLAT:msg # указатель на выводимую строку
# OFFSET FLAT означает использовать тот адрес,
# который msg будет иметь во время загрузки
mov edx, len # длина строки
int 0x80 # вызов ядра
mov eax, 1 # системный вызов № 1 — sys_exit
xor ebx, ebx # выход с кодом 0
int 0x80 # вызов ядра

Другим широко распространенным компилятором ассемблера для Linux является Netwide Assembler (NASM, вызываемый командой nasm). NASM использует синтаксис Intel. Кроме того, синтаксис директив ассемблера NASM частично совпадает с синтаксисом MASM. Пример приведенной выше программы для ассемблера NASM выглядит следующим образом:

section .data
msg db "Hello, world!\n"
len equ $-msg ; символу len присваевается длина строки
section .text
global _start ; точка входа в программу
_start:
mov eax, 4 ; системный вызов № 4 — sys_write
mov ebx, 1 ; поток № 1 — stdout
mov ecx, msg ; указатель на выводимую строку
mov edx, len ; длина строки
int 80h ; вызов ядра
mov eax, 1 ; системный вызов № 1 — sys_exit
xor ebx, ebx ; выход с кодом 0
int 80h ; вызов ядра

Кроме перечисленных ассемблеров в среде Linux можно использовать ассемблеры FASM и YASM. Оба поддерживают синтаксис Intel, но FASM имеет свой синтаксис директив, а YASM синтаксически полностью аналогичен NASM и отличается от него только типом пользовательской лицензии. В дальнейшем изложении материала все примеры будут даваться применительно к синтаксису, используемому NASM. Желающим использовать GAS можно порекомендовать статью о сравнении этих двух ассемблеров. Кроме того, при использовании в GAS директивы .intel_syntax noprefix различия между ними будут не столь значительными. Тексты программ, подготовленные для NASM, как правило, без проблем компилируются и YASM.

Структура программы

Программы в Linux состоят из секций, каждая из которых имеет свое назначение [6]. Секция .text содержит код программы. Секции .data и .bss содержат данные. Причем первая содержит инициализированные данные, а вторая — не инициализированные. Секция .data всегда включается при компиляции в исполняемый файл, а .bss в исполняемый файл не включается и создается только при загрузке процесса в оперативную память. Начало секции объявляется директивой SECTION имя_секции. Вместо директивы SECTION можно использовать директиву SEGMENT. Для указания конца секции директив не существует — секция автоматически заканчивается при
объявлении новой секции или в конце программы. Порядок следования секций в программе не имеет значения. В программе обязательно должна быть объявлена метка с именем _start – это точка входа в программу. Кроме того, метка точки входа должна быть объявлена как глобальный идентификатор директивой GLOBAL _start. Так как имя точки входа предопределено, то необходимость в директиве конца программы END отпадает: в NASM данная директива не поддерживается.
При создании многомодульных программ все метки (идентификаторы переменных и функций), которые предполагается использовать в других модулях, необходимо объявить как глобальные с помощью директивы GLOBAL. Наоборот, все идентификаторы, реализованные в других модулях и объявленные там, как глобальные, необходимо объявить как внешние директивой EXTERN. Функция сложения двух чисел sum, рассмотренная в предыдущей лабораторной работе, в NASM будет выглядеть так:

SECTION .text
global sum
sum:
push ebp
mov ebp, esp
mov eax, [ebp+8]
add eax, [ebp+12]
pop ebp
ret

Использование библиотечных функций

В программах на ассемблере можно использовать функции библиотеки Си. Для использования функции ее надо предварительно объявить директивой EXTERN. Например, для того. чтобы использовать функцию printf необходимо предварительно указать выполнить следующую директиву:
EXTERN printf
Программу hello можно модифицировать так, чтобы она использовала для вывода информации не функцию API Linux, а функцию printf библиотеки Си. Код программы, назовем ее hello-c, будет выглядеть так:

SECTION .data
msg db "Hello, world!",0
fmt db "%s",0Ah
SECTION .text
GLOBAL _start ; точка входа в программу
EXTERN printf ; внешняя функция библиотеки Си
_start:
push msg ; второй параметр - указатель на строку
push fmt ; первый параметр - указатель на формат
22
call printf ; вызов функции
add esp, 4*2 ; очистка стека от параметров
mov eax, 1 ; системный вызов № 1 — sys_exit
xor ebx, ebx ; выход с кодом 0
int 80h ; вызов ядра

Компиляция программ, использующих библиотечные функции ничем не отличается от компиляции программ, использующих только функции API. Различия появляются только на этапе компоновки. Особенности компоновки будут рассмотрены далее.

Отличия NASM от MASM

  • NASM чувствителен к регистру символов
  • NASM требует квадратные скобки для ссылок на память
  • NASM не хранит типы переменных
  • NASM не поддерживает ASSUME
  • NASM не поддерживает модели памяти
  • Обозначения операций в NASM совпадают с языком СИ

Компиляция и запуск

nasm -f elf hello.asm
gcc hello.o
chmod +x a.out
./a.out

Руководство по сборке x86

Руководство по сборке x86
University of Virginia Computer Science
CS216: Программа и представление данных, весна 2006 г.

19 ноября 2018 года

Содержание: Регистры | Память и Адресация | Инструкции | Соглашение о вызовах

В этом руководстве описаны основы 32-битного языка ассемблера x86. программирование, охватывающее небольшое, но полезное подмножество доступных инструкции и директивы ассемблера.Есть несколько разных языки ассемблера для генерации машинного кода x86. Тот, который мы будем использовать в CS216 - ассемблер Microsoft Macro Assembler (MASM). МАСМ использует стандартный синтаксис Intel для написания кода сборки x86.

Полный набор инструкций x86 большой и сложный (Intel x86 наборы инструкций содержат более 2900 страниц), и мы не рассматриваем все это в этом руководстве. Например, существует 16-битное подмножество x86 набор инструкций.Использование 16-битной модели программирования может быть довольно сложный. Имеет сегментированную модель памяти, больше ограничений на регистр использование и так далее. В этом руководстве мы ограничим наше внимание более современные аспекты программирования x86 и углубиться в набор инструкций только достаточно подробно, чтобы понять основы программирования x86.

Ресурсы

Регистры

Современные (т.е. 386 и более поздние) процессоры x86 имеют восемь 32-битных общих регистры назначения, как показано на рисунке 1.Имена регистров в основном исторический. Например, EAX раньше назывался аккумулятор, так как он был использован рядом арифметических операций, и ECX был известен как счетчик, так как он использовался для удержания цикла индекс. Принимая во внимание, что большинство регистров утратили свои особые цели в современный набор команд, по соглашению, два зарезервированы для специальных цели - указатель стека (ESP) и базовый указатель (ЕВР).

Для EAX, EBX, ECX и EDX регистры, подразделы могут быть использованы.Например, наименее 2 значащих байта EAX можно рассматривать как 16-битный регистр называется AX. Младший байт AX может быть используется как один 8-битный регистр под названием AL, в то время как наиболее значащий байт AX может использоваться как один 8-битный регистр называется AH. Эти имена относятся к одному и тому же физическому регистр. Когда двухбайтовое количество помещается в DX, обновление влияет на значения DH, DL и EDX. Эти подрегистры в основном являются остатками от старших, 16-битные версии набора команд.Тем не менее, они иногда удобно при работе с данными размером менее 32 бит (например, 1-байтовые символы ASCII).

При обращении к регистрам в сборке язык, имена не чувствительны к регистру. Например, имена EAX и eax относятся к одному регистру.


Рисунок 1. Регистры x86

Режимы памяти и адресации

Объявление Статических Областей Данных
Вы можете объявить статические области данных (аналог глобальных переменных) в Сборка x86 с использованием специальных ассемблерных директив для этой цели.Данные декларации должны предшествовать .DATA директивы. Следуя этой директиве, директивы DB, DW и DD могут использоваться для объявления одного, двух и четырех байтов расположение данных соответственно. Объявленные места могут быть помечены имена для последующего использования - это похоже на объявление переменных имя, но придерживается некоторых правил более низкого уровня. Например, места объявленные в последовательности будут расположены в памяти рядом друг с другом.

Пример объявления:

.ДАННЫЕ
вар DB 64
вар2 БД?
DB 10
X DW?
Y DD 30000

В отличие от языков высокого уровня, где массивы могут иметь много измерений и доступны по индексам, массивы на ассемблере x86 просто количество клеток, расположенных непрерывно в памяти.Массив может быть объявлен просто перечислив значения, как в первом примере ниже. Два других Обычные методы, используемые для объявления массивов данных, - это директива DUP и использование строковых литералов. Директива DUP говорит ассемблеру дублировать Выражение заданное количество раз. Например, 4 DUP (2) эквивалентно 2, 2, 2, 2.

Некоторые примеры:

Z ДД 1, 2, 3
байт DB 10 DUP (?)
обр. DD 100 DUP (0)
ул БД "привет", 0
Адресация памяти
Современные x86-совместимые процессоры способны обрабатывать до 2 32 байта памяти: адреса памяти имеют ширину 32 бита.В примеры выше, где мы использовали метки для ссылки на области памяти, эти метки фактически заменяются ассемблером на 32-битный количества, которые указывают адреса в памяти. В добавок.

Язык программирования ассемблера

Этот курс можно пройти только по подписке. Вы можете играть только первые 3 главы бесплатно. Нажмите здесь, чтобы воспользоваться подпиской
Курс ассемблера предназначен для тех, кто хочет написать ассемблер для Windows и Linux.Он использует свободно доступный ассемблер NASM, который является полнофункциональным и создает объектный код в различных форматах. Преобладающие процессоры сегодня используют набор инструкций Intel и все примеры в ходе использования этого набора инструкций. Курс охватывает базовую информацию, необходимую для программирования на ассемблере, и формы, которые должны принимать программы для работы в системах. Некоторое время затрачивается на низкоуровневый ввод-вывод, но многие примеры взаимодействуют с основными программами Си. Основное внимание в курсе уделяется написанию функций на ассемблере, которые можно вызывать из языков более высокого уровня.Чтобы начать обучение сегодня, просто нажмите на ссылку фильма.

Это курс по программированию на ассемблере. Это начальный курс, хотя предварительных условий для курса нет, предполагается, что вы знакомы с компьютером. Например, курс начинается с обзора бинарной системы, если вы знакомы с булевой алгеброй, у вас не возникнет проблем с ней.Курс охватывает только те части, которые вам необходимо знать для предстоящих операций, однако, если вы новичок в системе счисления с основанием 2, возможно, вам придется немного поучиться вне учебы, в этом нет ничего сложного, но если вы Я никогда не видел это прежде, чем это может сбить с толку. Вам нужно будет иметь несколько вещей, чтобы иметь возможность запускать программы и выполнять эксперименты, описанные в уроках, у вас должно быть несколько основных предметов. Во-первых, вам понадобятся примеры компьютерного программирования для Linux или Windows для обеих систем, и многие из этих примеров будут работать в обеих системах.Теперь на этом компьютере вам понадобится текстовый редактор, все, что позволяет редактировать простые файлы ASCII, подойдет. У меня есть свои редакторы, и я использую их в этом курсе, чтобы продемонстрировать списки кода, я не даю никаких рекомендаций текстового редактора, это ваше дело. Вам понадобится компилятор C, он используется в курсе двумя способами: во-первых, когда вы пишете программы на языке ассемблера, вы часто хотите связать их как функции и вызывать их из других языков, и я покажу вам, как это сделать.По другой причине выполнение ввода и вывода на ассемблере может быть утомительным, как вы увидите, поэтому для этой цели могут использоваться подпрограммы C, что значительно упрощает демонстрацию работы языка ассемблера. Вам понадобится подключение к Интернету, чтобы иметь возможность загрузить и установить ассемблер, используемый в курсе, и, наконец, вам потребуется терпение. Программирование на ассемблере - это не то, что происходит быстро, это требует времени, даже для выполнения самых простых дел - времени. Было проведено множество тестов на производительность труда программиста, и результаты показывают, что программист создает одинаковое количество строк кода независимо от того, какой язык используется, и для того, чтобы что-то сделать, требуется гораздо больше строк языка ассемблера, чем в других языках.Я уже упоминал булеву алгебру, и именно с этого начинается курс, следующее, о чем мы поговорим, - это компьютер, видимый изнутри. Вам необходимо понять ЦП и регистры, а также то, как адресуется память, затем объясняется ассемблер NASM, он свободно загружается и используется для всех примеров, показанных в этом курсе. Затем в курсе рассматривается построение программы, включая детали, связанные с одной инструкцией, и общее построение программы.Это самый большой раздел курса и заполнен рядом примеров. Макросы начинались с языка ассемблера, так что макросы ассемблера были предшественниками языков более высокого уровня. Макросы пригодятся сотнями способов, они очень важная часть программирования на ассемблере. Булева алгебра снова посещается, но на этот раз с точки зрения логической операции, выполняемой ЦП. Функции языка ассемблера и вызовы функций очень важны, одна из самых полезных вещей, которые вы можете сделать с языком ассемблера, - это написание функций, агрегированные данные включают в себя структуры блоков данных и блоков данных, в том числе адресации C-структур и битовых полей C.Числа с плавающей точкой работают совершенно иначе, чем целые числа на языке ассемблера, есть другие ассемблеры, есть отладчики, утилиты и так далее. Этот последний раздел является их обзором. Это основные моменты курса, но есть и другие подробности, включенные здесь и там, курс предназначен для тех, кто уже является программистом, но хочет иметь возможность программировать на ассемблере. Таким образом, нет ничего о программировании, методологии, стиле или о чем-то кроме механики ассемблера, вам не нужно ничего знать о программировании, чтобы пройти курс, но чем лучше вы будете заниматься программированием, тем легче будет этот курс.

  • Курс: Программирование на ассемблере
  • Автор: Артур Гриффит
  • SKU: 33995
  • ISBN: 1-935320-44-0
  • Рабочие файлы: Да
  • Подписи:
  • Тема: Программирование
  • Первые 3 главы курсов доступны для игры БЕСПЛАТНО (первая глава только для курсов QuickStart! И MasterClass!).Просто нажмите на ссылку фильма, чтобы сыграть урок.
,

% PDF-1,7 % 25316 0 объектов > endobj Xref 25316 277 0000000016 00000 n 0000009201 00000 n 0000009391 00000 n 0000009430 00000 n 0000009574 00000 n 0000009721 00000 n 0000009909 00000 n 0000009989 00000 n 0000010691 00000 n 0000011881 00000 n 0000013074 00000 n 0000014259 00000 n 0000014470 00000 n 0000014631 00000 n 0000036298 00000 n 0000040081 00000 n 0000040316 00000 n 0000040542 00000 n 0000051606 00000 n 0000051832 00000 n 0000062920 00000 n 0000063151 00000 n 0000063214 00000 n 0000063327 00000 n 0000063455 00000 n 0000063542 00000 n 0000063623 00000 n 0000063773 00000 n 0000063912 00000 n 0000064068 00000 n 0000064215 00000 n 0000064351 00000 n 0000064504 00000 n 0000064647 00000 n 0000064735 00000 n 0000064836 00000 n 0000064991 00000 n 0000065095 00000 n 0000065203 00000 n 0000065319 00000 n 0000065444 00000 n 0000065565 00000 n 0000065676 00000 n 0000065789 00000 n 0000065897 00000 n 0000066013 00000 n 0000066141 00000 n 0000066243 00000 n 0000066367 00000 n 0000066529 00000 n 0000066640 00000 n 0000066782 00000 n 0000066899 00000 n 0000067031 00000 n 0000067144 00000 n 0000067327 00000 n 0000067434 00000 n 0000067539 00000 n 0000067666 00000 n 0000067781 00000 n 0000067932 00000 n 0000068052 00000 n 0000068196 00000 n 0000068311 00000 n 0000068428 00000 n 0000068520 00000 n 0000068622 00000 n 0000068739 00000 n 0000068852 00000 n 0000069027 00000 n 0000069137 00000 n 0000069266 00000 n 0000069395 00000 n 0000069542 00000 n 0000069664 00000 n 0000069782 00000 n 0000069917 00000 n 0000070087 00000 n 0000070194 00000 n 0000070308 00000 n 0000070443 00000 n 0000070588 00000 n 0000070732 00000 n 0000070921 00000 n 0000071003 00000 n 0000071150 00000 n 0000071289 00000 n 0000071408 00000 n 0000071552 00000 n 0000071698 00000 n 0000071828 00000 n 0000071971 00000 n 0000072119 00000 n 0000072265 00000 n 0000072392 00000 n 0000072538 00000 n 0000072686 00000 n 0000072833 00000 n 0000072974 00000 n 0000073117 00000 n 0000073264 00000 n 0000073399 00000 n 0000073540 00000 n 0000073677 00000 n 0000073818 00000 n 0000073964 00000 n 0000074101 00000 n 0000074248 00000 n 0000074389 00000 n 0000074513 00000 n 0000074694 00000 n 0000074795 00000 n 0000074897 00000 n 0000075034 00000 n 0000075155 00000 n 0000075281 00000 n 0000075395 00000 n 0000075574 00000 n 0000075674 00000 n 0000075767 00000 n 0000075885 00000 n 0000076007 00000 n 0000076120 00000 n 0000076225 00000 n 0000076343 00000 n 0000076462 00000 n 0000076560 00000 n 0000076664 00000 n 0000076770 00000 n 0000076892 00000 n 0000076999 00000 n 0000077098 00000 n 0000077214 00000 n 0000077334 00000 n 0000077441 00000 n 0000077552 00000 n 0000077651 00000 n 0000077758 00000 n 0000077879 00000 n 0000077993 00000 n 0000078117 00000 n 0000078238 00000 n 0000078380 00000 n 0000078518 00000 n 0000078635 00000 n 0000078741 00000 n 0000078849 00000 n 0000078957 00000 n 0000079056 00000 n 0000079154 00000 n 0000079262 00000 n 0000079369 00000 n 0000079467 00000 n 0000079570 00000 n 0000079708 00000 n 0000079808 00000 n 0000079931 00000 n 0000080082 00000 n 0000080193 00000 n 0000080289 00000 n 0000080406 00000 n 0000080527 00000 n 0000080645 00000 n 0000080757 00000 n 0000080868 00000 n 0000080979 00000 n 0000081095 00000 n 0000081208 00000 n 0000081322 00000 n 0000081432 00000 n 0000081541 00000 n 0000081649 00000 n 0000081788 00000 n 0000081918 00000 n 0000082053 00000 n 0000082152 00000 n 0000082286 00000 n 0000082404 00000 n 0000082528 00000 n 0000082694 00000 n 0000082799 00000 n 0000082918 00000 n 0000083051 00000 n 0000083212 00000 n 0000083348 00000 n 0000083461 00000 n 0000083614 00000 n 0000083735 00000 n 0000083843 00000 n 0000083982 00000 n 0000084107 00000 n 0000084248 00000 n 0000084368 00000 n 0000084470 00000 n 0000084572 00000 n 0000084688 00000 n 0000084793 00000 n 0000084949 00000 n 0000085115 00000 n 0000085257 00000 n 0000085385 00000 n 0000085495 00000 n 0000085609 00000 n 0000085719 00000 n 0000085823 00000 n 0000085925 00000 n 0000086028 00000 n 0000086129 00000 n 0000086233 00000 n 0000086336 00000 n 0000086438 00000 n 0000086537 00000 n 0000086639 00000 n 0000086741 00000 n 0000086842 00000 n 0000086943 00000 n 0000087045 00000 n 0000087134 00000 n 0000087220 00000 n 0000087324 00000 n 0000087422 00000 n 0000087526 00000 n 0000087632 00000 n 0000087734 00000 n 0000087843 00000 n 0000087949 00000 n 0000088056 00000 n 0000088164 00000 n 0000088272 00000 n 0000088371 00000 n 0000088469 00000 n 0000088568 00000 n 0000088666 00000 n 0000088764 00000 n 0000088867 00000 n 0000088976 00000 n 0000089078 00000 n 0000089178 00000 n 0000089279 00000 n 0000089380 00000 n 0000089480 00000 n 0000089590 00000 n 0000089702 00000 n 0000089874 00000 n 0000089981 00000 n 0000090131 00000 n 0000090249 00000 n 0000090346 00000 n 0000090515 00000 n 0000090615 00000 n 0000090715 00000 n 0000090829 00000 n 0000090942 00000 n 0000091087 00000 n 0000091183 00000 n 0000091279 00000 n 0000091375 00000 n 0000091471 00000 n 0000091567 00000 n 0000091663 00000 n 0000091759 00000 n 0000091855 00000 n 0000091951 00000 n 0000092047 00000 n 0000092143 00000 n 0000092239 00000 n 0000092335 00000 n 0000092431 00000 n 0000092527 00000 n 0000092623 00000 n 0000092719 00000 n 0000092815 00000 n 0000092911 00000 n 0000093007 00000 n 0000093103 00000 n 0000093199 00000 n 0000005836 00000 n прицеп ] >> startxref 0 %% EOF 25592 0 объектов > поток xY TTU3 ›a`aP: ˁAN $ yD # 7 脭 r.Ќ [X2sēc! S>) / o3, mN ݹ sO [г

л] z | -l; c6 /jΏϙ.ĕkW$ToE{.}4Klb+cM9mIQWk\ҳҪ8;U0]X&-q0CY)q gίC9S4k9Yf} ݱ о> НРГ% z4sc` [GPW; WxҺNY} p` / w-, H8B> = г;]> ޯ + LkOVy '˪? -Ou8u = 6 = PFk> n; RS8_ \ R ~ yW f0tjR7Vm ~ SmH9n

iɳ qyxx @ Z: I? J: 0΁] 0XԄ5w.lWѶ $} Q1] Кейр

.
Простая английская Википедия, бесплатная энциклопедия

В информатике ассемблер - это программа, которая превращает язык ассемблера в машинный код. [1] Ассемблер - это программа, которая берет базовые компьютерные инструкции и преобразует их в последовательность битов, которую процессор компьютера может использовать для выполнения своих основных операций. Некоторые люди называют эти инструкции языком ассемблера, а другие используют термин язык ассемблера.

Большинство компьютеров поставляются с указанным набором базовых инструкций, которые соответствуют основным операциям машины, которые может выполнять компьютер.Например, инструкция «Загрузка» заставляет процессор перемещать строку битов из места в памяти процессора в специальное место хранения, называемое регистром. Предполагая, что процессор имеет по меньшей мере восемь регистров, каждый из которых пронумерован, следующая инструкция переместит значение (строку битов определенной длины) в ячейке памяти 3000 в место хранения, называемое регистром 8:

 л 8,3000
 

Программист может написать программу, используя последовательность этих инструкций ассемблера.Эта последовательность инструкций ассемблера, известная как исходный код или исходная программа, затем указывается программе ассемблера при запуске этой программы. Программа на ассемблере принимает каждый программный оператор в исходной программе и генерирует соответствующий поток битов или шаблон (последовательность нулей и единиц данной длины). Вывод ассемблерной программы называется объектным кодом или объектной программой относительно входной исходной программы. Последовательность 0 и 1, составляющая объектную программу, иногда называют машинным кодом.Затем объектная программа может быть запущена (или выполнена) в любое время. На самых ранних компьютерах программисты фактически писали программы в машинном коде, но вскоре были разработаны языки ассемблера или наборы инструкций для ускорения программирования. Сегодня программирование на ассемблере используется только там, где необходим очень эффективный контроль над процессорами. Однако для этого требуется знание набора команд конкретного компьютера. Исторически сложилось так, что большинство программ написаны на языках высокого уровня, таких как COBOL, FORTRAN, PL / I и C.Эти языки легче изучать и быстрее писать программы, чем на языке ассемблера. Программа, которая обрабатывает исходный код, написанный на этих языках, называется компилятором. Как и ассемблер, компилятор принимает высокоуровневые операторы языка и превращает их в машинный код.

Более новой идеей в подготовке и переносимости программ является концепция виртуальной машины. Например, используя язык программирования Java, операторы языка компилируются в общую форму машинного языка, известного как байт-код, который может выполняться виртуальной машиной, своего рода теоретическая машина, которая приближается к большинству компьютерных операций.Затем байт-код может быть отправлен на любую компьютерную платформу, которая ранее загружена или встроена в виртуальную машину Java. Виртуальная машина знает о конкретных длинах команд и других особенностях платформы и обеспечивает выполнение байт-кода Java.

  1. Питер Калингаерт, Ассемблеры, компиляторы и перевод программ (Лондон: Питман, 1979), с. 9
,

Отправить ответ

avatar
  Подписаться  
Уведомление о