Newsgroup: it.comp.os.linux.development
Titolo: GCC - Inline assembly

Devo scrivere delle routines in assembler per un OS che girera' su m68K,
utilizzando GCC & Co.
Avrei  bisogno  di  accedere  a  elementi di  una  struttura  da  inline
assembly, ho  visto che  altri compilatori  lo permettono  usando questo
metodo:
	move.l 	contextPtr, a0;
	pointer a0, ProcContext;
	movea.l	a0->stack, a5;
Ovviamente contextPtr e' un puntatore a ProcContext.
Esiste il modo di farlo pure con  GCC, o per accedere ad elementi di una
struttura devo conoscerne l'offset  e accederci per register-indirect :(
?
-- 
                                                                     __
 __                                                              _  ///
| _        Student in Computer Science, Swiss Federal Institute  \\///
|__|iambo      of Technology - mailto:
ggia...@iiic.ethz.ch
       \X/

 Avrei  bisogno  di  accedere  a  elementi di  una  struttura  da  inline
Puoi usare espressioni C come argomenti delle istruzioni asm:
  struct s { int i ; char c; } ss;
  asm ("incl %0" : "+g" (ss.i));
anche se in modo un po' prolisso (nell'esempio - per x86 - si incrementa
di uno ss.i). Inoltre devi sapere bene quali effetti collaterali possono
avere le tue istruzioni asm (se sporcano registri, ecc.), e segnalarli
al compilatore.
Ciao
 David
-- 
<d.santinoli presso mi. flashnet. it>

 istruzioni asm (se sporcano registri, ecc.), e segnalarli al compilatore.
Cosa intendi  per "istruzioni che sporcano  i registri" ? Cioe',  io non
uso mai i registri nei miei listati, posso andare sul sicuro ?
Aprofitto  ancora  di te: In  diverse  guide  online, sento  parlare  di
"clobbered registers", ma non ho capito che cosa vuol dire :-/ ...


uso mai i registri nei miei listati, posso andare sul sicuro ?
'Spetta n'attimo, giambo.
Come, non usi i registri?
E che istruzioni assembly usi, se non usi i registri?
-- 
           |Save our planet!
  Ciao     |Save wildlife;
  roberto  |For your E-MAIL use only recycled Bytes !!
           |roberto poggi  
rpo...@softhome.net

 "clobbered registers", ma non ho capito che cosa vuol dire :-/ ...
Sono registri il cui valore viene cambiato in modo imprevedibile da
alcune istruzioni. E` importante che il compilatore sappia quali
istruzioni clobberano quali registri, in modo da salvare questi ultimi
(se contengono risultati utili) prima di emettere le istruzioni
colpevoli, e ripristinarli poi. Esempio tipico: i registri
("call-clobbered") che vengono sacrificati per ospitare i parametri da
passare a una funzione, o i risultati da questa ritornati.


"clobbered registers", ma non ho capito che cosa vuol dire :-/ ...
Sono proprio quelli. Alla fine dell'istruzione devi segnalare quali registri
hai smanacciato al compilatore (a meno che non ripristini tu direttamente lo
stato). Ora non ricordo la sintassi. Ma se vuoi la ritrovo. Anzi meglio di
mando un esperimento cazzone che ha stupito un profe rincoglionito, inline e
gestione del coprocessore i386.
--
  	Giuseppe "Cowo" Corbelli  -->>  Riding on Linux-2.2.16
    **ANTI-SPAM** -- **Substitute IHATESPAM with cowo to reply by mail**
  -<! Any sufficiently advanced bug is indistinguishable from a feature. !>-
                 Rich Kulawiec

 E che istruzioni assembly usi, se non usi i registri?
Qualcosa stile (m68k, non i386):
==
void byteCopy(register Address targetAddress, register Address
	sourceAddress, register unsigned long int nbBytes) {
	asm (
		"1:\t"
		"moveb %4@+, %0@+\n"	/* M[targetAddress++] = M[sourceAddress++] */
		"cmp #1, %5\n"	/* if 1 <= nbBytes */  
		"dble %2, 1b\n"	/* then nbBytes-- ; goto label "1" */
		: "=a" (targetAddress), "=a" (sourceAddress), "=d" (nbBytes)
		: "0" (targetAddress), "1" (sourceAddress), "2" (nbBytes)
		);
}
==
Che dovrebbe copiare "nbBytes" da "sourceAddress" a "targetAddress".


Qualcosa stile (m68k, non i386):
Ach, scusa, sono tanti anni che ho un cerebral-wrapper attivo
sull'architettura x86 :-(
Ma credo che in ogni caso in realta' anche il 68xxx, per fare cio' che
scrivi qui sotto, vada a pasticciare con i registri, indirizzi source,
dest e lunghezza da qualche parte li mettera', prendendoli dalle tue
strutture _esterne_.


 colpevoli, e ripristinarli poi.
Urka, questo  non e' bello. Cioe', se  devo scrivere una routine  per il
context-switch che  mi salvi il valore  dei registri, non posso  dire al
compilatore di -uh- clobberare i  registri, dato che potrei rischiare di
trovarmi con dei valori salvati incoerenti, no ?
Ci sono  controindicazioni (Oltre  a, immagino, perdita  di prestazioni)
nel segnalare _tutti_ i registri come "clobbered" ?


 strutture _esterne_.
allora, tra le istruzioni con due operandi l'unica che possono non
accedere ai registri è MOVE.
Tutte le altre devono avere almeno un registro come operando .
-- 
Non c'è più forza nella normalità, c'è solo monotonia.

 strutture _esterne_.
Vero, ma poiche' il compilatore sa benissimo in quali registri li ha
caricati, non c'e` nessun bisogno di marcare qualcosa come clobbered (ed
anzi sarebbe dannoso).


 nel segnalare _tutti_ i registri come "clobbered" ?
Non credo. Al massimo il compilatore genera una sfilza di PUSH prima
della tua istruzione, e di POP dopo.


 della tua istruzione, e di POP dopo.
E' quello che volevo sentirmi dire, grazie :) !


 profe rincoglionito, inline e gestione del coprocessore i386.
Volentieri, il mio EMail dovrebbe essere nella firma.
