; TABELLA DI RIFERIMENTO DELLA PROGRAMMAZIONE 68000 - LIVELLO 2 ! ! _..'/\ |\___/| /\-.._ ./||||||\\. ||||||| .//||||||\. ./||||||||||\\|.. ||||||| ..|//||||||||||\. ./||||||||||||||\||||||||||||||||||||/|||||||||||||\. ./|||||||||||||||||||||||||||||||||||||||||||||||||||||\. /|||||||||||||||||||||||||||||||||||||||||||||||||||||||||\ '|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||` '||||' `|||||/' ``\|||||||||||||/'' `\||||||' `|||` |/' `\|/ \!|||||||!/ \|/' `\| V V \|||||/ V V ` ` \|||/ ' ' \./ Autore: Fabio Ciucci V Sinteticamente gli indirizzamenti: ******************************************************************************* move.l #123,xxxx ; Immediato: si copia il valore dopo il # nella ; destinazione. ******************************************************************************* move.l xxxx,$50000 ; Assoluto lungo (una longword, fino dove arrivano ; gli indirizzi di memoria nel computer!). ******************************************************************************* move.l xxxx,$500.w ; Assoluto corto (indirizzo minore di $7FFF) ; Esempio: "move.l 4.w,a6" ******************************************************************************* move.l xxxx,D0 ; Registro dati diretto (si puo' accedere con .b ; .w e .l ad un registro dati Dx) ******************************************************************************* move.l xxxx,A0 ; Registro indirizzi diretto (si puo' accedere solo ; con .w e .l ad un registro indirizzi Ax, infatti ; un "move.b d0,a0", per esempio, darebbe errore, ; allo stesso modo, move.b a0,d0 non e' assemblato!) ******************************************************************************* move.l xxxx,(a0) ; Registro indirizzi indiretto (cioe' si scrive non ; nel registro Ax, ma nell'indirizzo presente in ; quel registro; si puo' operare con .b, .w e .l). ******************************************************************************* move.l xxxx,(a0)+ ; Registro indirizzi indiretto con post-incremento ; ( dopo la copia a0 viene incrementato di 1 se ; l'istruzione era .b, di 2 se .w e di 4 se .w) ******************************************************************************* move.l xxxx,-(a0) ; Registro indirizzi indiretto con pre-decremento ; (prima il registro viene decrementato, di 1 se ; l'istruzione era .b, di 2 se .w e di 4 se .w, poi ; avviene la copia indiretta, ossia nell'indirizzo ; contenuto nel registro ******************************************************************************* move.l xxxx,$123(a0) ; Registro indirizzi indiretto con OFFSET (distanza ; di indirizzamento) - la copia viene fatta nell' ; indirizzo risultante dalla somma del contenuto del ; registro indirizzi ax piu' l'offset, che puo' ; variare tra -32768 e 32767 ($8000-$7fff) ******************************************************************************* move.l xxxx,$12(a0,d0.w) ; Reg. indirizzi indiretto con OFFSET e INDICE ; In questo caso, viene sommato l'indice oltre ; che l'offset e il contenuto del registro Ax. ; l'offset puo' variare tra -128 e +127 ($80-$7f) ; l'indice e' un registro dati o indirizzi del quale ; si possono considerate solo i suoi 16 bit bassi ; o tutti i 32 bit. Esempi: move.l $12(a1,d2.w),d0 move.l $12(a1,d2.l),d0 move.l $12(a1,a2.w),d0 move.l $12(a1,a2.l),d0 ******************************************************************************* move.l offset(PC),xxxx ; Relativo al PC con OFFSET; normalmente si ; fa calcolare l'offset dall'assemblatore, mettendo ; una label dove vogliamo scrivere, Es: move.l label(pc),d0 ; La label deve essere non piu' lontana di $7fff ; perche' l'offset massimo e' -32768 e 32767 ; nota: solitamente si puo' mettere il (PC) solo ; all'operando sorgente, e non a quello destinaz., ; per esempio "move.l d0,label(PC)" non esiste. ; L'unica istruzione che lo permette e' il BTST: btst.l d0,label(pc) ; Allo stesso modo, 3 istruzioni che hanno un solo ; operando permettono questo indirizzamento jmp label(pc) jsr label(pc) pea label(pc) ******************************************************************************* move.l offset(PC,d0.w),xxxx ; Relativo al PC con OFFSET e INDICE; anche in ; questo caso si fa calcolare l'offset ; dall'assemblatore usando le label. Ricordarsi ; che la label non puo' distare piu' di 127 bytes ; dall'istruzione, essendo l'ofsset max -127,+127 move.l LabCanez(pc,d2.w),d0 move.l LabGatto(pc,d2.l),d0 move.l LabTopol(pc,a2.w),d0 move.l Labella1(pc,a2.l),d0 ; Come abbiamo visto per l'indirizzamento senza ; indice, si puo' usare questo indirizzamento ; solo per l'operando sorgente, non per quello ; destinazione. Per esempio: ; "move.l d0,Labella1(pc,a2.l)" non esiste! ; Solo il BTST lo permette al secondo operando: btst.l d0,label(pc,a2.w) ; E 3 istruzioni ad un solo operando: jmp label(pc,d2.l) jsr label(pc,d2.w) pea label(pc,d2.w) ******************************************************************************* move.w d1,SR ; Status Register ******************************************************************************* move.w d1,ccr ; Condition Code Register ******************************************************************************* Ancora piu' sinteticamente: Modi di indirizzamento Sintassi ---------------------- -------- Registro dati diretto Dn Registro indirizzi diretto An Registro indirizzi indiretto (An) Registro indirizzi indiretto con Post-Incremento (An)+ Registro indirizzi indiretto con Pre-Decremento -(An) Registro indirizzi indiretto con Offset (max 32767) w(An) Registro indirizzi indiretto con Offset e Indice b(An,Rx) Assoluto corto w Assoluto lungo l Program Counter con Offset (calcolato dall'asmone) w(PC) Program Counter con Offset e Indice b(PC,Rx) Immediato #x Status Register SR Condition Code Register CCR ****************************************************************************** LO STATUS REGISTER: SR SR - Status Register: i 16 bit di questo registro vengono utilizzati solo quando il processore si trova in modo supervisore; altrimenti sono disponibili al programmatore gli 8 bit meno significativi, detti Registro dei Codici Condizione (CCR). Vediamo nel dettaglio le funzioni di SR: bit 0 - Carry (C): settato ad 1 quando il risultato di un'addizione genera un riporto ('carry'), o quando un sottraendo e' maggiore del minuendo, cioe' quando una sottrazione ha richiesto un "prestito". Il bit di Carry contiene inoltre il bit piu' o meno significativo di un operando sottoposto ad uno shift o ad una rotazione. Viene posto a zero quando l'ultima operazione eseguita non ci sono ne' riporti, ne' "prestiti". bit 1 - Overflow (V): viene settato se il risultato dell'ultima operazione tra numeri dotati di segno il risultato e' troppo grande per poter essere contenuto nell'operando destinazione, ad esempio se tale risultato supera i limiti -128..+127 nel campo byte. Ad esempio, la somma.b 80+80 genera un oVerflow, avendo superato +127. In campo .w i limiti sono -32768..+32767, e in campo .l sono -/+ 2 miliardi. Da notare che la somma 80+80 in campo byte non setta il flag di Carry ed eXtend, ma solamente quello di oVerflow, dato che 160 non supera 255, il massimo contenibile in un byte per numeri normali. bit 2 - Zero (Z): settato quando l'operazione genera il risultato zero (utile anche per controllare il decremento di un contatore), nonche' quando si confrontano due operandi uguali. bit 3 - Negative (N): viene settato ad 1 se in una operazione il bit alto del numero, in formato complemento a due, e' settato. In pratica se il risultato e' un numero negativo questo bit e' settato, altrimenti azzerato. Il complemento a due si ottiene facendo il complemento a uno dell'operando (ossia invertendo tutti i bit), aggiungendo quindi 1; ad esempio, +26 in binario e' %000110010; il suo complemento a uno e'%11100101 (inversione dei bit 0 in bit 1 e viceversa); aggiungendo 1 si ottiene %11100110. Il bit 7, detto bit di segno, viene copiato nel bit 3 dello Status Register; Nel caso di -26, ad esempio, N viene settato, indicando un numero negativo. bit 4 - Extend (X): e' una ripetizione del bit di Carry, e viene usato in operazioni effettuate in notazione BCD (Binary Coded Decimal: il numero decimale 20, ad esempio, non viene rappresentato con 00010100, ma nella forma due decine, zero unita' 0010 0000) ed in operazioni binarie 'estese' come ADDX e SUBX, versioni particolari delle istruzioni di addizione e sottrazione ADD e SUB. Terminologia: Nibble: Meta' di un byte. Non indirizzabile direttamente, ma estraibile dal byte mediante shift e rotazioni. In un byte si distingue il nibble destro (detto "basso" o "meno significativo") dal nibble sinistro (detto "alto" o "piu' significativo"). Stack: Letteralmente "catasta". E' un'area di memoria destinata alla memorizzazione di valori di registri secondo il principio LIFO, last in first out (l'ultimo valore inserito, trovandosi in cima allo stack, e' anche il primo ad essere estratto). Quando, nel corso del programma, si esegue una diramazione ad una subroutine, sullo stack viene salvato il valore di PC (Program Counter), che viene "ripreso" come indirizzo di ritorno a subroutine terminata. DIRETTIVE E CARATTERISTICHE DELL'ASSEMBLATORE: L'assemblatore che si usa, nel nostro caso ASMONE, trasformando il listato da formato testo ascii nel binario corrispondente alle istruzioni e ai dati contenuti nel listato stesso, ha certe convenzioni e direttive particolari che occorre sapere, oltre alla conoscenza delle istruzioni 68000 vere e proprie elencate in questo testo. Innanzittutto, se non viene specificato il .b, .w o .l nell'operazione, viene assunto sempre il .w; un esempio: move d0,d1 Viene assemblato come "MOVE.W d0,d1". Allo stesso modo un: move d0,12(a0,d0) Viene assemblato come MOVE.W D0,$0C(A0,D0.W) Dunque anche il registro usato come indice, il d0, e' considerato come d0.w. Per questo conviene SEMPRE specificare i vari .b, .w e .l nelle istruzioni, o non saremo mai sicuri di come puo' essere assemblato il tutto, specialmente da assemblatori diversi. Esistono anche altre particolarita', ad esempio per le istruzioni come ASL,ASR, LSR,ROL,ROR,ROXL,ROXR, che quando SHIFTANO di un solo bit, possono essere scritte in queste due forme: (form1) ROL.w #1,d3 ROL.w #1,(a0) (form2) ROL.w d3 ROL.w (a0) Naturalmente, quando lo shift e' maggiore di 1, occorre specificarlo! Es: ROL.W #3,d3 Altra IMPORTANTE operazione che svolge l'assemblatore, e' quella di riconoscere automaticamente quando e' il caso di usare MOVEA oppure MOVE, infatti esistono due istruzioni specifiche: il MOVE per le copie generiche, tranne che per le copie verso registri INDIRIZZI An, le quali sono compiute dal MOVEA. Infatti: MOVE.W #10,d0 MOVE.W d1,d2 Sono operazioni di competenza del MOVE, mentre: movea.w d1,a0 movea.l a1,a0 movea.w (a1),a0 Sono operazioni verso Registri Indirizzi, dunque sono dei MOVEA!!! In realta' non occorre far caso ogni volta che facciamo un MOVE se si tratta di un MOVE o di un MOVEA, perche' ASMONE lo fa per noi. Basta specificare sempre MOVE: move.w a1,a0 move.l d0,d1 move.l (a1),a4 Queste 3 istruzioni saranno assemblate correttamente, la prima e la terza come MOVEA e la seconda come MOVE. Addirittura si puo' specificare il MOVEA quando non e' corretto, e verra' assemblato il MOVE giusto: movea.l d0,d1 Sara' assemblato come MOVE.L d0,d1. Lo stesso vale per ADD,ADDI,ADDA ; SUB,SUBI,SUBA ; AND,ANDI ; CMP,CMPA,CMPI EOR,EORI ; OR,ORI: prendiamo il caso dell'ADD come esempio per tutti questi gruppi di istruzioni: esistono 3 tipi di ADD, che svolgono la medesima operazione di addizione, ma su operandi diversi. Ebbene, se si deve fare una somma di questo tipo: ADD.W d0,d1 Ossia tra registri, ad esempio, basta il semplice ADD, mentre se si deve fare una somma ad un registro indirizzi, esiste l'apposito ADDA: ADDA.L d0,a1 Nel caso si debba aggiungere una costante, con l'indirizzamento #immediato, esiste l'apposito ADDI: ADDI.W #10,d0 Ebbene, dovremmo scrivere sempre gli ADD stando attenti al caso: add.l (a1),d0 addi.b #$12,(a1) add.b label(pc,d2.w),d0 adda.l (a1),a0 add.w $12(a1,d2.l),d0 adda.w (a1)+,a0 add.b $12(a1,d2.w),d0 adda.w label(pc),a0 addi.w #$1234,$1234.w Naturalmente quasi tutti gli assemblatori accettano sempre ADD in compilazione e assemblano correttamente a seconda dei casi gli ADDI/ADDA/ADD: add.l (a1),d0 add.b #$12,(a1) add.b label(pc,d2.w),d0 add.l (a1),a0 add.w $12(a1,d2.l),d0 add.w (a1)+,a0 add.b $12(a1,d2.w),d0 add.w label(pc),a0 add.w #$1234,$1234.w Dunque scrivete sempre ADD, risparmiandovi di dividere l'istruzione nei 3 casi diversi, tanto e' pur sempre un ADD. Lo stesso vale per le altre istruzioni che hanno il "fratellino" che finisce in "A" per i registri indirizzi e quello che finisce in "I" per le costanti. Dunque, scrivete sempre: MOVE - per le istruzioni MOVE,MOVEA ADD - per le istruzioni ADD,ADDI,ADDA SUB - per le istruzioni SUB,SUBI,SUBA AND - per le istruzioni AND,ANDI CMP - per le istruzioni CMP,CMPA,CMPI EOR - per le istruzioni EOR,EORI OR - per le istruzioni OR,ORI Gli inventori degli assemblatori ci hanno cosi' fatto risparmiare 10 istruzioni "accorpandone" 17 in 7 solamente. Se pero' siete dei maniaci e degli esteti del listato, potete specificarle tutte e 17 (mah!). Un consiglio: quando agite su un registro indirizzi, ad esempio: MOVEA.L xxxx,Ax CMPA.L Ax,Ax ADDA.L xxxx,Ax SUBA.L xxxx,Ax Usate sempre l'estensione .L, e mai .W, perche' gli indirizzi sono lunghi una longword, e soprattutto perche' queste istruzioni su registri non agiscono come le altre per l'indirizzamento .W, tanto piu' che non permettono l'indirizzamento .B: infatti, un MOVEA.W o un ADDA.W agisce non sulla word bassa del registro indirizzi, ma sull'intero indirizzo, ricavando la word alta "mancante" riempiendola con una replica del bit 15 della word bassa. Dunque avviene una cosa simile all'istruzione EXT (vedi), e questo puo' essere FATALE per alcune routines, infatti questa "estensione" fa si' che, per esempio, un ADD.W #$5000,a0 aggiunga il valore $00005000, perche' il bit 15 di $5000 e' azzerato, mentre un ADD.W #$B000,A0 provoca un aumento di $FFFFB000, il che e' MOOOLTO pericoloso. Un'altra convenzione e' che si puo' indicare il registro A7 anche come SP: movem.l d0-d7/a0-a6,-(SP) <-> movem.l d0-d7/a0-a6,-(a7) Proseguiamo con le convenzioni: sappiamo che per definire un'area di commento occore precedere il testo del commento da un ;, ma si puo' farlo precedere anche da un asterisco "*": move.l 4.w,a6 * commento! Ma, in realta', dopo l'istruzione si potrebbe mettere direttamente il commento senza precederlo col "*" o col ";" move.l 4.w,a6 commento! Comunque non tutti gli assemblatori permettono questo, e dipende anche dai settaggi delle preferenze dei vari assemblatori, quindi mettete sempre il ";" prima dei vostri commenti. Ci sono inoltre gli EQUATES, ossia dei simboli che possiamo definire e usare al posto dei numeri nel listato: NumeroPlanes EQU 5 move.w #NumeroPlanes,d0 ; assemblato come MOVE.W #5,d0 Gli equates si definiscono in modo simile alle label, hanno nomi a piacere e non devono essere spaziate dall'inizio, ma a differenza delle label non devono terminare con i ":". Si puo' usare anche il simbolo "=" al posto dell'EQU. - - - - - - - - - - Naturalmente, se nel listato sono presenti delle operazioni o delle espressioni, sono risolte in fase di assemblaggio, come avviene digitando l'espressione col comando "?" della linea comandi ASMONE: MOVE.W #(10*3)+2,D0 ; Sara' assemblato come MOVE.W #32,d0 MOVE.W #(30/3)+2,d0 ; Sara' assemblato come MOVE.W #12,d0 Allo stesso modo, si possono usare anche gli Equates definiti per i calcoli: move.w #NumeroPlanes*2,d0 Oppure si possono specificare degli Offset da alcune label: MOVE.b d0,SPRITE+1 MOVE.b d1,SPRITE+2 MOVE.b d2,SPRITE+3 Abbiamo gia' visto che questo e' equivalente a fare 3 label per ogni byte dopo la label SPRITE. Per esempio, per scrivere 100 bytes dopo una label: MOVE.B d0,label+100 E Cosi' via. L'Offset in memoria sara' calcolato come ci fosse una label in quel punto, 100 bytes dopo label (il numero conta sempre 1 byte!!!). Infine, si puo' addirittura specificare una LABEL-EQUATE, per esempio: HSTART: EQU *+1 VSTOP: EQU *+2 MIOSPRITE: ; lunghezza 13 linee dc.b $50 ; VSTART dc.b $90 ; HSTART dc.b $5d ; VSTOP dc.b $00 ... In questo caso, viene usato l'"*" dopo l'EQU, che indica "QUESTO INDIRIZZO", allora possiamo tradurre in:" HSTART: questo indirizzo+1", eccetera. Anziche' porre le label tra un byte e l'altro, le abbiamo definite ad una certa distanza da tale byte, ma abbiamo scritto "l'offset" da quel punto. Riferendoci a HSTART e VSTOP, ci riferiremo proprio ai bytes indicati, come se le label fossero poste in quel punto. (Es: "M HSTART": 90 5c 00 ....) Tale stratagemma dell'"*" dopo l'EQU, puo' essere usato anche per Bcc: move.l d1,d2 ;*-6 move.b (a1),d0 ;*-2 cmp.b (a1),d0 beq.s *-2 dbra d2,*-6 In questo caso possiamo calcolare NOI anziche' l'assemblatore l'offset dei Bcc e dei DBcc. (ho messo dei ; per indicare gli offset come fossero label per rendere piu' chiaro). Usare le label pero' e' piu' comodo sicuramente. Potrebbe servire quando si usa la direttiva "REPT", che ripete una data parte di dati o di codice: REPT 100 ; 100 volte dc.b "ciao" ENDR ; fine della parte da ripetere Con questa direttiva scriviamo in memoria 100 volte "CIAO". Naturalmente se si usassero delle LABEL, si verificherebbe l'errore di "label gia' esistente", dunque si potrebbe usare lo stratagemma di prima: REPT 100 ; 100 volte move.l d1,d2 ;*-6 move.b (a1),d0 ;*-2 cmp.b (a1),d0 beq.s *-2 dbra d2,*-6 ENDR Eiste il comando "SET", che "definisce una variabile" per cui si puo', tramite il REPT, creare tabelle o istruzioni in sequenza, per esempio, per creare una tabella con i multipli del 2: TABELLA: dc.b 0,2,4,6,8,10,12,14,16,18 Possiamo scrivere anche: TABELLA: A set 0 ; A e' uguale a 0 Rept 10 ; fai 10 volte il pezzo da qua a ENDR Dc.b A*2 ; metti (col dc.b) A*2 in memoria A set A+1 ; Al prossimo "loop" A vale A+1 Endr Comunque il comando REPT non esiste in tutti gli assemblatori, e spesso rende meno chiaro il listato. E' meglio non usarlo, a meno che non salvi molto lavoro di scrittura "manuale". Per terminare questa parte, ecco le operazioni che possono essere inserite nelle "espressioni" risolte durante l'assemblaggio, utilizzabili anche quando si usa il comando "?" per calcolare dalla linea comandi: () Parentesi ; Es: (10*2)*(3+5) * Moltiplicazione + Addizione - Sottrazione / Divisione ^ Potenza (es: "moveq #2^4,d0", assemblato "moveq #16,d0") Ci sono anche gli operatori LOGICI sui bit: & AND (Es: %01010101 & %00001111 = %00000101 ! OR (Es: %00110011 ! %11000011 = %11110011 ~ EOR (Es: %00110011 ~ %11000011 = %11110000 >> Shift a destra (Es: $50>>2 = $14) (%01010000>>2 = 00010100) << Shift a sinistra (come LSL) (Es: $14<<2 = $50) Questi possono essere utilissimi, as esempio per "spezzare" dei valori .l in due words, eccetera. Facciamo il caso che si voglia dividere un valore lungo una word, mettendone gli 8 bit bassi in una destinazione e gli 8 bit alti in un'altra. Possiamo definire un Equate, e lasciar "spezzare" il valore all'ASMONE, per cui possiamo semplicemente cambiare tale equate ogni volta: MICS equ 2000 move.b #(MICS&$FF),$400(a4) ; metti il byte basso del time move.b #(MICS>>8),$500(a4) ; metti il byte alto del time Dunque, (MICS&$FF) significa MICS AND $00FF, e come sappiamo l'AND azzera i bit che sono a zero nel secondo operando e lascia invariati, in questo caso, i primi 8, cioe' $FF (%11111111). Essendo MICS = 2000, cioe' $07d0, in questo caso l'operazione e' $07d0 AND $00FF, per cui il risultato e' $00d0, cioe' il BYTE BASSO della word. L'istruzione viene assemblata cosi': MOVE.B #$D0,$400(A4) Per quanto riguarda MICS>>8, equivale a $07d0 LSR 8, dunque il risultato e' il bite alto "spostato" al posto di quello basso: $0007: MOVE.B #$07,$500(A4) Si possono spezzare anche indirizzi di una longword nelle 2 word, da porre per esempio nei puntatori ai bitplanes: INDIRIZZO EQU $75000 Copperlist: dc.w $e0,INDIRIZZO>>16 ; word alta dell'indirizzo in BPL0PTH dc.w $e2,INDIRIZZO&$FFFF ; word bassa dell'indirizzo in BPL0PTL Il tutto sara' assemblato cosi': dc.w $e0,$0007 dc.w $e2,$5000 Comunque e' meglio puntare i bitplanes con una routine e non usare indirizzi assoluti (FISSI). Questi operatori sono molto utili, tenetene sempre conto. Continuiamo con le direttive: END ; indica la fine del listato, quello che compare dopo l'END ; non viene assemblato Ci sono poi le direttive riguardanti l'allineamento a indirizzi pari o dispari: EVEN ; allinea ad indirizzo PARI (allineamento a word, 16 bit) ODD ; allinea ad indirizzo DISPARI Even va messo quando si verifica l'errore "Word at odd address" Altrimenti si puo' allineare a LongWord (32 bit), o a 64 bit. Per esempio, nel CHIPSET AGA, certe risuluzioni grafiche necessitano che i bitplanes siano ad indirizzi multipli di 64 bit, ed e' indispensabile questa direttiva. Per allineare si usa CNOP: CNOP Size[,Offset] cnop 0,2 ; allinea a word (16 bit) equivalente di EVEN cnop 0,4 ; allinea a longword (32 bit) cnop 0,8 ; allinea ad indirizzi divisibili per 8 (64 bit) cnop 0,16 ;... A proposito dell'allineamento, RICORDATEVI CHE su un indirizzo dispari si puo' operare solo in .b, altrimenti un MOVE.W o MOVE.L #xxx,indirizzo causa un crash totale con reset e GURU MEDITATION/SOFTWARE FAILURE. Altra direttiva importantissima e' il DC.x, che permette di mettere in memoria bytes, words e longwords, specialmente di Copperlist o Tabelle: dc.w $1234,$4567,$8901,$2345... Oppure per label usate come variabili con una word/long solitaria: GfxBase: dc.l 0 Nel caso si scriva del testo, si usa il dc.b e si pone il testo tra "" o '' dc.b "Testo ASCII",$10,$11 E si puo' anche inserire qualche valore decimale/esadecimale/binario sulla stessa linea, basta separarli con le virgole. Ricordatevi che dopo un testo o comunque un dc.b occorre mettere EVEN per pareggiare l'eventuale indirizzo dispari formatosi! Sua variante e' il DCB.x, che mette in memoria vari bytes, words o longwords tutte uguali, es: dcb.b 100,$55 ; metti in memoria 100 bytes $55 consecutivi dcb.b 50,$00 ; 50 bytes azzerati Questa direttiva si puo' anche chiamare BLK, per compatibilita' col vecchio (ma mitico) SEKA, comunque il DCB e' universalmente usato. Per le SECTION BSS, che sono formate da soli spazi azzerati, si usa la direttiva "DS.x [numero]" per specificare quanto spazio occupare: ds.b 100 ; 100 bytes azzerati A proposito di SECTION, le SECTION sono una direttiva dell'assemblatore, che ha la funzione di allocare le parti del codice in CHIP o in FAST ram secondo la loro natura. Nei computer schifosi o antichi, per esempio MSDOS o altri reperti archeologici, non esiste il multitasking e il rilocamento dei programmi nella memoria, infatti i programmi sono fatti per andare a certi indirizzi precisi di memoria, mentre su amiga ogni programma puo' essere "rilocato", ossia copiato in una qualsiasi zona di memoria libera, in tal modo vari programmi possono stare in memoria contemporaneamente, ad indirizzi diversi. Vabbe', su windows cel'hanno fatta a far caricare piu' di un programma in memoria, ma ognuno lavora da solo, senza multitasking HAHAHAHAHAHAH! Comunque, l'effetto di queste direttive si vede quando viene salvato l'eseguibile con "WO", infatti nel formato dell'eseguibile Amiga ci sono gli Hunk, ossia i pezzi di memoria decisi con le SECTION, i quali sono allocati dal mitico sistema Operativo dell'Amiga. Pero' quando assembliamo e Jumpiamo da ASMONE, se l'opzione di AutoAlloc non e' attivata tutte le section sono assemblate in CHIP (Se alla domanda iniziale di ASMONE abbbiamo risposto C!). L'ASMONE ha questa opzione disattivata di default. Potete attivarla dal menu' Project/Preferences../AutoAlloc. Comunque l'AutoAlloc occupa piu' memoria, dato che oltre alla memoria allocata all'inizio, ogni volta ne alloca ALTRA per le section. Le SECTION possono essere CODE, DATA o BSS, e andare in CHIP o in PUBLIC, cioe' in qualsiasi memoria. Per indicare che vada in chip si aggiunge un _C: Section Grafica,DATA_C ; Dati, in CHIP!!! Altra direttiva UTILISSIMA e' l'INCBIN, che carica dei dati da disco mettendoli in memoria al punto dove si trova l'incbin stesso: INCBIN "nomefile" Una direttiva analoga e' INCLUDE "nomefile", che invece include un testo ASCII, ossia un pezzo di sorgente, che viene assemblato assieme al resto del codice. Puo' servire per includere routines "universalmente usate", ad esempio la Startup iniziale o la routine della musica. Vi sconsiglio pero' di usare troppo gli INCLUDE, perche' poi si arriva al punto di non sapere piu' cosa c'e' nel listato, e se si perde uno dei file da includere addio assemblaggio! Direttiva associata a INCBIN e INCLUDE e' INCDIR, che stabilisce da quale directory caricare i files. Attenzione pero' che l'ultimo INCDIR vale anche per tutti i listati caricati dopo, dunque se i files da includere sono da un'altra parte dovere riazzerare l'INCDIR. Esempi: INCDIR "dh0:sorgentozzi/mieifiles" ; decide una dir INCDIR "" ; Azzera l'incdir, la directory diventa quella corrente Vi sconsiglio di riempire i vostri sorgenti di INCDIR e INCLUDE, perche' poi se vi trovate, ad esempio, a dover portare un vostro listato a far vedere ad un amico, dovrete copiarvi nel dischetto il vostro povero sorgente diviso in una cinquantina di piccoli files, e sara' dura trovarli tutti nelle svariate directory dell'hard disk. Infine, una volta giunti da tale amico, dovrete cambiare tutti i Path degli INCDIR, e magari vi accorgerete che manca un file e dovete rinunciare a far vedere il programma in funzione. Un uso intelligente di INCBIN/INCLUDE puo' essere questo: per quanto riguarda l'INCBIN, si possono includere nel listato in formato DC.x tutti i dati piu' piccoli, sotto i 5Kb, per esempio sprites o piccole tabelle, mentre per le figure o le musiche, piu' grandi di 5K, converra' caricarle con INCBIN: in questo modo i files "sciolti" sono il meno possibile, e il listato e' corto. Per gli INCLUDE lo stesso: al massimo si puo' usare l'include per la routine della musica o per la startup, ma nessuno vieta di non usare proprio per nulla INCLUDE. Nel corso e' servito per includere la "Startup1.s", piu' che altro per risparmiare spazio, che su un dischetto non e' tantissimo. Volete forse negare la soddisfazione che c'e' a fare "A" e "J" e veder partire subito una decina di solidi 3D con una cinquantina di palline e gli equalizzatori senza 30 minuti di caricamento di INCLUDE???? Ci sarebbero anche gli assemblaggi condizionali (IF,ENDIF,ELSE), ma non sono poi la fine del mondo, se serviranno saranno spiegati piu' avanti. Anche le MACRO (MACRO,ENDM) verranno spiegate, eventualmente, piu' avanti, dato che non sono che una specie di EQUATE di varie istruzioni, e se ne puo' fare ampiamente a meno. Per quanto riguarda le Label Locali (quelle precedute dal .) credo siano una frivolezza stupida, per chi non ha fantasia e non riesce a inventare nomi per le sue label. Vabbe', forse sono stato esagerato, comunque non credo che abbiano una utilita' particolare. Dunque, per favore, non mi fate sorgenti con label precedute dal punto, o vi allontanerete dalla mia corrente ideologica coderistica. - - - - - - - - - - Una coppia di direttive che al giorno d'oggi non sono piu' alla moda, ma che potrebbero servire sono ORG e LOAD, che servono in pratica per allocare ad indirizzi FISSI, ASSOLUTI, NON RILOCABILI le istruzioni del nostro listato. Ovviamente queste istruzioni venivano usate ai tempi in cui venivano fatte quelle demo che oggi infatti non funzionano sui computer moderni, dato che SE SI FA UN DEMO/GIOCO IN FORMATO FILE ESEGUIBILE, NON CI DEVONO ESSERE INDIRIZZI ASSOLUTI, MA SOLTANTO SECTION! L'utilizzo di ORG e LOAD e' rimasto per fare un demo/gioco autoboot, ossia una TRACKMO (demo su tracce con caricamento non dos) o un gioco di vecchio tipo. D'altronde le ultime demo e gli ultimi giochi sempre piu' sono installabili su Hard Disk, specialmente le MIGLIORI demo e i MIGLIORI giochi (vedi BANSHEE e BRIAN THE LION per i giochi). Credo proprio che nei prossimi anni spariranno i dischi autoboot, perche' non sono installabili su HD, ne' facilmente convertibili per CD32 o CD-ROM, e l'unica cosa certa e' che gli HD e i CD-ROM saranno sempre piu' diffusi. E' anche il fatto che TUTTO si installa su HD che ha fatto diffondere i PC MSDOS cosi' bene (anche le tangenti, si sa). In questo corso avevo pensato di includere una ampia parte su come farsi un loader da disco via hardware, e magari un copiatore alla XCOPY/DCOPY, visto che ne ho iniziato a programmare uno anni fa. Ma alla luce della realta', ho invece deciso di non trattare per niente il caricamento MFM via hardware o autoboot, perche' vi insegnerei a fare qualcosa che penalizzerebbe la vostra produzione!!!! La migliore opzione e' quella di caricare files con il sistema operativo, ossia la DOS.LIBRARY, come fanno le ultime e migliori produzioni. Dunque vi esorto a programmare solo files eseguibili, da salvare con "WO", diffidando degli obsoleti autoboot e, peggio, di iniziare il listato cosi': ORG $30000 ; organizza il codice con indirizzi assoluti da $30000 LOAD $30000 ; assembla all'indirizzo $30000 Anche perche' se avete 1MB o 2MB di chip senza FAST, come A500+/a600 e a1200 di base, a $30000 c'e' caricato ASMONE stesso, il quale sara' sovrascritto e tutto andra' in GURU MEDITATION. (Mi ricordo ancora allo smau del 91 o del 92, i bambini stupidi che caricavano asmone sugli A600 e si chiedevano perche' non funzionassero i sorgenti rubati o copiati che volevano far passare per opera loro, HAHAHAHA! Ebbene, erano sorgenti che avevano trovato nei dischetti del lontano 1987-1988, ed erano pieni di ORG e LOAD HAHAHAHAH!). - - - - - - - - - Ci sono poi altre particolarita' a livello di assemblaggio che dipendono dai settaggi dell'ASMONE, e sono: Da menu: Assembler/assemble../Ucase=Lcase Questa opzione significa Upper case = Lower case, e si riferisce alle lettere maiuscole o minuscole che compongono le LABEL. Normalmente tale opzione e' settata, dunque l'assemblatore considera ugualmente le tettere maiuscole e minuscole, e si puo' scrivere: LaBel1: btst #6,$bfe001 bne.s labEL1 Cioe' basta che la "parola" che costituisce la label sia la stessa, anche se le maiuscole e minuscole sono differenti. Con Ucase=Lcase disabilitato, invece, le due label sarebbero considerate differenti, e ci sarebbe una segnalazione di errore, si dovrebbe scrivere: Label1: btst #6,$bfe001 bne.s Label1 O comunque ogni label dovrebbe essere uguale, anche per quanto riguarda la disposizione delle maiuscole e minuscole. Dato che solitamente ci si dimentica quali caratteri abbiamo messo maiuscoli e quali minuscoli, e' meglio lasciarla settata, viva la liberta'! Una nota sulle label: il comando "=S" dalla linea comandi mostra la SIMBOLTABLE che e' la lista di tutte le label con gli offset. Ultima nota: se compilate un sorgente con un milione di label, al momento del salvataggio dell'eseguibile con "WO" va tutto in GURU MEDITATION, a meno che non eseguiate un bel "stack 20000" prima di eseguire ASMONE. ****************************************************************************** Legenda: ------ Dn Registro Dati (n compreso tra 0-7) An Registro Indirizzi (n compreso tra 0-7 - A7 e' detto anche SP) b costante a 8-bit ( da -128 ($80) a +127 ($7f) ) w costante a 16-bit ( da -32768 ($8000) a +32767 ($7fff) ) l costante a 32-bit ( massimo $FFFFFFFF ) x costante a 8-, 16-, 32-bit Rx Registro Indice; tra questi ci possono essere: Dn.W 16 bits bassi di un Registro Dati Dn.L Tutti i 32 bits di un Registro Dati An.W 16 bits bassi di un Registro Indirizzi An.L Tutti i 32 bits di un Registro Indirizzi -------------------------- \==================================| _=_ \_________________________________/ ___/==+++==\___ """\__ \""" |======================================/ \__ \_ / .. . _/--===+_____+===--"" \__ \ _/. .. _/ `+' USS ENTERPRISE \__ \ __/_______/ \ / NCC-1701 ___-\_\-'---==+____| ---==O=- __--+" . . . "==_ / \ / |. . .. -------- | \ "==+_ . . -------- | / ""\___ . .. __==" """"--=--"" _____ _.-' `-._ .-' ` || || ' `-. _______________ _ ,' \\ // `. / || \ /' \ _,-----._ / \ |_______________||_/ / \\ ,' \ | | / `. // \ | | _] \ / \ ,---. / \ // \ | \__,--------/\ ` | \ / \ / |/ - | ) ,-' _,-' |- |\-._ | .---, | -| == | || /_____,---' || |_|= || `-',--. \| -| - ==| |:(==========o=====_|- || ( O )|| -| - --| || \~~~~~`---._|| | |= || _,-.`--' /| -| - ==| ) `-.__ `-. |- |/-' | `---' | -| == | | / `--------\/ , | / \ / \ |\ - | __|____|_______ _ ] / \ / `---' \ / \\ / | || \ \ // `._/ | | \_.' \\ / \_______________||_/ \ / `-----' \ / `. // \\ ,' `-._ || || _,-' `-._____,-' -------------------------- ; ELENCO DI TUTTE LE ISTRUZIONI del 68000: NOTA: non sono presenti le istruzioni quasi mai usate, come ABCD,SBCD,SBCD, LINK,UNLK, non viene descritta ne' listruzione TAS, che non va usata su Amiga, ne' ILLEGAL o RESET, che generano solamente una eccezione e un reset delle periferiche. Legenda: Condition codes: C Carry (ossia riporto) V Overflow (Fuori misura) Z Zero N Negative X Extend Stati dei Condition codes: Simbolo Significato ------- ----------- * Settato a seconda del risultato dell'operazione - Non modificato 0 Azzerato 1 Settato U Stato dopo l'operazione INDEFINITO I Settato dal dato immediato Altri simboli per l'indirizzamento: Operando di indirizzamento effettivo Dato immediato