szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[oktatas:programozás:assembly|< Assembly]]


====== Assembly nyelv ======

  * **Szerző:** Sallai András
  * Copyright (c) 2011, Sallai András
  * Szerkesztve: 2011, 2014, 2019
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC BY-SA 4.0]]
  * Web: https://szit.hu

===== Az Assembly nyelvről =====

Az Assembly nyelv utasításai igékből és változókból állnak. A programozás könnyebb, a programkód olvashatóbb.

Az Assembly fordító műveleti kódokkal és címekkel helyettesíti az utasításokat. A legtöbb cím relatív,
mert a valódi címek csak futáskor állnak elő.

Később megjelent a makro assembly, amely lehetővé tette, meghívható makrók létrehozását, amely nagyban megkönnyítette a programozást.

===== EXE program készítése =====


Szükségünk van egy **fordítóra** és egy **linkerre**. Ajánlott az nasm fordító és az alink linker használata.
A következő példáknál ezt fogom használni.

Készítsük el az alábbi kódot:

kiir.asm
  mov ah, 02h
  mov dl, 2ah
  int 21h
  mov ah, 4ch
  int 21h

Ez után fordítsuk le az nasm fordítóval:
  nasm -f win32 -o kiir.obj kiir.asm

A fordítás után a linkerrel készítsük el a futtatható állományt:
  alink kiir.obj

A program ezek után futásra kész, amely egy csillagot kell a 
képernyőre írjon. 

Elemzés
  * Karaktert szeretnénk kiíratni, ezért az ah regiszterbe 2-t teszünk. 
  * A csillag karaktert szeretnénk kiíratni, ezért annak ASCII kódját a dl regiszterbe tesszük.
  * A 21-es DOS megszakítás használjuk a karakter kiírására
  * Előkészülünk a program befejezéséhez.
  * Megint a 21-es DOS megszakítást használjuk, de most kilépésre.


===== ELF bináris készítése =====
Az ELF bináris a Unix alapú rendszerek formátumba.Az első ELF binárist System V Release 4 rendszeren
mutatták be, ami később szabvánnyá vált. Az ELF a **Executable and Linkable Format** rövidítése.
==== Intel szintaktika ====

<code asm>
section .text

	global	_start
_start:

	mov	ebx,1
	mov	ecx,msg
	mov	edx,len
	mov	eax,4
	int	0x80

	mov	ebx,0
	mov	eax,1
	int	0x80

section	.data
msg	db	"Helló világ!",0x0a
len	equ	$ - msg

</code>

Fordítás és linkelés:
<code>
nasm -f aout main.asm
ld -s -o main main.o
</code>



==== AT&T szintaktika ====

<code asm>
.text					

			
    .global _start


_start:


	movl	$len,%edx
	movl	$msg,%ecx
	movl	$1,%ebx
	movl	$4,%eax
	int	$0x80

	movl	$0,%ebx
	movl	$1,%eax
	int	$0x80

.data

msg:
	.ascii	"Helló Világ!\n"
	len = . - msg

</code>

Fordítás és linkelés:
<code>
as -o main.o main.S
ld -s -o main main.o
</code>

==== C inline assembly ====

Az Assembly nyelvet más nyelvekbe beépítve is használjuk. 
A következő példa egy C nyelvű program, amelybe egy Assembly részt építettem.

<code c main.c>
#include <stdio.h>		
	
void main()
{
	int x = 10, y;
	
	asm (
		"movl %1, %%eax;"
		"movl %%eax, %0;"
		:"=r"(y)	/* y is output operand */
		:"r"(x)		/* x is input operand */
		:"%eax");	/* %eax is clobbered register */
	
	printf("eax tartalma%d\n", y);
}
</code>

===== 64 bites nasm =====

Példa:

<code asm hello.asm>
section .data
	msg: db 'helló világ!', 10

section .text
	global _start

_start:
	mov		rax, 1
	mov 	rdi, 1
	mov		rsi, msg
	mov		rdx, 16
	syscall

	mov		rax, 60
	xor		rdi, rdi
	syscall
</code>


<code Makefile Makefile>
hello:	hello.asm
	nasm -felf64 hello.asm -o hello.o
	ld -o hello hello.o
</code>

===== Forrás =====

  * Igor Zhirkov:
    * Low-Level Programming
    * C, Assembly, and Program Execution on Intel 64 Architecture