Newsgroup: it.comp.os.linux.development
Titolo: Assembly GNU

Salve a tutti, ho scoperto oggi questo forum e mi fa piacere essermi
iscritto, spero di poter essere utile... :)
Ora veniamo al mio problema... 
Allora, da quando ho cominciato ad usare linux (nel 2000 circa) ho
imparato a programmare bene in C e ho imparato anche ad arrangiarmi con
altri linguaggi per lo scripting o la scittura di documenti... E da un
sacco di tempo che voglio imparare l'assembly ma solo ieri mi sono
deciso ad iniziare. Ho sfogliato un pò di HOWTO in inglese e in
italiano, Appunti di informatica libera e la documentazione di GNU as.
Da ieri ad oggi ho imparato solo come fare un interrupt su linux e sono
riuscito a scrivere solo 2 stupidi programmini, uno è il classico Ciao
mondo e l'altro legge il numero di argomenti passati sulla linea di
comando... Anzi lascio il codice che un buon parere sicuramente mi
aiuta... :)
HELLO:
Code:
--------------------
 
  message: .ascii "Ciao mondo!\n"
  length = . - message
 
  .section .text
 
  .globl _start
 
  _start:
  	mov $4, %eax
  	mov $1, %ebx
  	mov $message, %ecx
  	mov $length, %edx
  	int $0x80
  exit:
  	mov $1, %eax
  	mov $0, %ebx
  	int $0x80
 
--------------------
Numero di parametri (<A
HREF="
http://database.sarang.net/study/linux/asm/linux-asm.txt
">qui</A>
ho letto come sono gestiti i parametri alla linea di comando e cmq mi ci
sono volute un paio d'ore per farlo funzionare perchè non sapevo nemmeno
come si fa una somma... ):
Code:
--------------------
 
  newline: .byte 0x0A
  .section .text
  .globl _start
 
  _start:
 
  	mov %esp, %ecx
  	add $0x30, (%ecx)
  	mov $4, %eax
  	mov $1, %ebx
  	mov $1, %edx
  	int $0x80
 
  	mov $4, %eax
  	mov $1, %ebx
  	mov $newline, %ecx
  	mov $1, %edx
  	int $0x80
 
  	mov $1, %eax
  	mov $0, %ebx
  	int $0x80
 
--------------------
Quel che più mi affascina dell'assembly è che è tutto un'altro modo di
programmare, da quel che so (niente), non hai praticamente nulla se non
dei registri, uno stack e gli interrupt. 
Mi piacerebbe riuscire a fare qualcosa di interessante ma non riesco ad
entrare nell'ottica dell'assembly ovvero a capire come gestire le cose.
Mi spiego meglio: In un linguaggio come il C, ad esempio, so che se io
voglio aprire un file indicato dall'utente posso dichiarare una
variabile dove memorizzare il nome del file, chiamare una procedura che
mi legge il nome dallo standard input (ipotesi) e una che mi apre il
file e mi restituisce un puntatore al flusso. In assembly come posso
fare per gestire tutte queste cose?
Ad esempio il prossimo passo che vorrei fare è leggere gli argomenti,
ovvero le stringhe passate alla linea di comando. Nell'howto che ho
citato ho visto che esse sono memorizzate sullo stack dopo il numero di
argomenti. Oggi ho provato a scrivere un po di codice (non quello
dell'howto) ma non riesco a stampare un solo argomento (trovare il punto
in cui la stringa termina), e l'output è tutti gli argomenti seguiti da
tutte le variabili d'ambiente (presumo tutto lo stack). 
Qualcuno mi indicherebbe una buona guida o mi darebbe qualche dritta su
come procedere per imparare? 
Un'altra domanda, io ho iniziato da un giorno (2 con oggi) e ho
iniziato con l'assembler gnu, (da ignorante chiedo:) secondo voi è
giusta la mia scelta? c'è un assembler che potrebbe darmi più
possibilità? a me piacerebbe anche potermi staccare dal so GNU/Linux e
scrivere magari un pikkolo kernel completamente in'utile tanto per
togliermi sta soddisfazione... 
Beh ho scritto abbastanza, spero che qualcuno mi possa rispondere...
Ciauz!
-- 
Natan
------------------------------------------------------------------------
Natan's Profile: 
http://www.linuxforum.it/member.php?userid=1237
View this thread: 
http://www.linuxforum.it/showthread.php?t=22761

 possibilit�? a me piacerebbe anche potermi staccare dal so GNU/Linux e


 avanzato o se sono stato "maleducato" in qualcosa... :(
L'assembly e' fatto per scrivere cose veramente a basso livello, e su 
architetture molto semplici.
In un sistema moderno usarlo per cose diverse da "piccoli loop che 
vengono eseguiti migliaia di volte al secondo" o "gestori a basso 
livello da utilizzare in fase di boot" e` poco comune.
Tra l'altro i compilatori ottimizzano meglio degli esseri umani perche` 
e` umanamente MOLTO difficile tener conto quando si scrive codice della 
superscalarita` e delle pipeline dei processori moderni.
Tornando alla tua domanda (se non hai visitato 
asm.sourceforge.net
 vacci 
ci sono un sacco di informazioni a riguardo):
Un assemblatore molto usato su linux e` nasm.
Tutte le librerie di supporto per creare applicazioni userspace (glibc & 
co) hanno un interfaccia in C, per chiamarle dall'assembly devi usare la 
corretta ABI (su linux passi gli argomenti sullo stack, salti alla 
subroutine che ti sei definito come simbolo esterno (_fopen, _fread...) 
e al ritorno stai attento ai registri trashed).
Le syscall hanno un interfaccia differente, perche` in genere usano i 
registri e vanno invocate con una int $0x80 per uscire dalla modalita` user.
In ogni caso se vuoi programmare in assembly ti consiglio di usare 
dosbox o qualche altro emulatore e fare girare i tuoi programmi (il tuo 
microkernel x esempio) in quel contesto. Programmare applicazioni in 
assembly e` poco utile, l'efficacia del linguaggio la vedi quando con un 
a mov puoi settare il modo video del sistema o scrivere a video (ed a 
livello bios puoi farlo :) )
Bye,
  Gabry

> togliermi sta soddisfazione...
A parte le primissime fasi del boot (che tra l'altro in un'architettura 
x86 sono veramente schifose da gestire), praticamente tutti i kernel oggi 
sono scritti in C o al massimo in C++.
Se e` questo che ti interessa fare, guardati le parti di Linux scritte in 
asm, prendile e copiale, e scrivi tutto il resto in C.
Ci sono diversi progetti, anche educativi, su come scrivere un kernel 
(compreso Minix e il relativo libro di Tanenbaum). Alcuni sono anche 
kernel gia` pronti e documentati, che devi solo modificare o estendere, o 
di cui puoi prendere pezzi (lo scheduler, il fs, ecc.) per integrarli in 
un tuo progetto.
Oltre ai vari kernel opensource (Linux, BSD, Syllable, ecc.)
Bye.

 rispondere... Ciauz!
Premetto che non conosco molto l'assembler per Linux (che ha una 
sintassi diversa dall'assembler INTEL) però negli anni '80 ho usato 
tantissimo il Macro Assemblatore Microsoft per MS-DOS e quello Intel 
per sistemi embedded e ritengo che dopo qualche tempo è possibile 
usarlo quasi come il C.  A quei tempi i compilatori (ed anche i 
microprocessori) non erano ancora molto avanzati e, scritto un pseudo 
codice in C o PL/M, lo traducevamo in assembler manualmente.  Puoi 
anche tranquillamente linkare le librerie e chiamare le funzioni che 
include semplicemente tramite l'istruzione call.  In genere se non 
diversamente specificato il linker include l'oggetto cstart.o che 
provvede a chiamere il main, a preparare l'ambiente di environment e 
gli argomenti del comando.
Ti suggerisco di compilare un qualsiasi file .c passando al 
compilatore l'opzione -S e troverai un file .s che contiene 
l'assembler generato dal compilatore. Se non usi alcuna opzione di 
ottimizzazione troverai abbastanza facilmente la corrispondenza fra 
l'assembler ed i costrutti del codice C.
Detto questo il mio ultimo consiglio è di lasciar perdere l'assembler. 
  IMO è fatica sprecata ed i compilatori come il gcc creano del codice 
più efficiente.  Anche i SO di questi tempi sono scritti in C al 99,99%
Ciao
Giovanni
-- 
   A computer is like an air conditioner,
   it stops working when you open Windows.
   Registered Linux user #337974  < 
http://giovanni.homelinux.net/
 >

beh innanzitutto grazie per le risposte... 
Cmq so benissimo anch'io che l'assembly si usa pochissimo,
probabilmente non lo userò mai, comunque a me programmare piace
moltissimo e imparare l'assembly sarebbe una bella soddisfazione... :)
Grazie mille per le info su come creare dei so, ho scoperto 'OS
Development' (
http://www.osdev.org
), e devo dire che è molto molto
interessante, comunque non voglio scopiazzare qua e la per creare un
so... logicamente se scrivessi un kernel lo farei in C o in C++ e userei
l'assembly per fare il boot... :)
Grazie ancora... Christian.


 togliermi sta soddisfazione...
Guarda che scrivere un mini sistema opertivo non e' un'impresa
difficilissima, ci vuole solo molto tempo e buone volonta'. Molti anni
fa avevo scritto un abbozzo di kernel tutto in assembler. Avevo
implementato il bootloader, il gestore dei task, il gestore della
memoria, etc... Mancava completamente il loader (i pochi processi
partivano tutti all'inizio insieme al kernel) e non avevo ancora
implementato dei veri driver (tutti i processi avevano libero accesso
al video e al buffer di tastiera, niente accesso a disco).
Purtroppo non ho mai avuto il tempo (e la voglia) di finirlo.
Comunque se sei interessato qui puoi trovare molti tutorial a
riguardo:
http://www.osdever.net/
Inoltre su alt.os.development trovi molti thread interessanti.
Comunque considera che ormai scrivere un kernel tutto in asm non ha
senso. Di solito ti basta pochissimo assembler ed il resto lo scrivi
in C.
Saluti,
The Librarian

Si quel sito l'ho già visto ed è veramente fantastiko, purtroppo per me
io sono ancora all'inizio con l'assembly e quindi prima di provare a
scrivere un mio so (che poi alla fine è solo una prova, così per
togliermi lo sfizio) vorrei prima imparare l'assembly e quel che ci gira
intorno. Lo so che in assembly dovrei scrivere solo il bootloader e che
quindi potrei benissimo prendere e copiare il codice (che oltretutto mi
pare sia libero), ma a me interessa anche imparare quindi per ora cerco
di capire come funziona programmare in assembly poi quando sarò in grado
scrivero il mio bootloader e poi un micro kernel assolutamente in'utile,
tutto qui. :)
PS: Veramente molti compimenti per il tuo lavoro, peccato che non lo
hai finito... :(
