Escolar Documentos
Profissional Documentos
Cultura Documentos
03.b
C. Fantozzi, A. Gardich
(revisione di S. Congiu)
52
label:<sp>istruzione<sp>operandi<sp>@commento Ogni campo deve essere separato da uno o pi spazi I label devono iniziare dal primo carattere della riga Le istruzioni non cominciano mai dal primo carattere della riga: devono essere precedute da almeno 1 spazio Tutti e tre le sezioni ... : ... @ ... sono opzionali Esistono inoltre: direttive per lassemblatore pseudo-istruzioni
Architettura degli Elaboratori 1 2009
52
2009
Esempio di file .s
Label
.text .global _start _start: mov r0, #0x100 ciclo: subs r0, r0, #1 bne ciclo @ Inizia il programma
52
Istruzione
@ esce al sistema
.data maschera: .long 0xAAAAAAAA stringa: .ascii "Pippo" .bss .lcomm spazio, 100 .end
Architettura degli Elaboratori 1
Direttiva
Sezione
2009
Classi di indirizzamento
Modo 1: per istruzioni di elaborazione dati ADC, ADD, AND, BIC, CMN, CMP, EOR, MOV, MVN, ORR, RSB, RSC, SBC, SUB, TEQ, TST Modo 2: per Load&Store di word o unsigned byte LDR, LDRB, STR, STRB Modo 3: per L&S di halfword o signed byte LDRH, LDRSB, LDRSH, STRH Modo 4: per L&S di registri multipli LDMxx, STMxx
52
2009
52
2009
Modo 1: esempi
mov R0, #0 add R3, R3, #1 cmp R7, #1000 bic R9, R8, #0xff00 mov R2, R0 add R4, R3, R2 mov R2, R0, LSL #2 add R9, R5, R5, LSL #3 sub R9, R5, R5, ASR #3 rsb R9, R5, R5, ASR #3 mov R5, R3, RRX mov R7, R4, ROR R3 @ @ @ @ @ @ @ @ @ @ @ @ @ @ R0 0 R3 R3+1 cc (R71000) R9 R8 and not 0xff00 R2 R0 R4 R3+R2 R2 R0*4 R9 R5+R5*8 = R5*9 R9 R5R5/8 R9 R5/8R5 R5 R3 ruotato esteso a destra di una posiz. R7 R4 ruotato a destra di R3 posizioni
52
2009
sintassi: LDR|STR{B} Rd, <addressing_mode2> 52 <addressing_mode2> un indirizzamento indiretto con registro [Rn], che pu avere una delle seguenti forme: offset immediato offset da registro offset da registro scalato pre-incremento immediato pre-incremento da registro pre-incremento da registro scalato post-incremento immediato post-incremento da registro post-incremento da registro scalato
Architettura degli Elaboratori 1 2009
Modo 2: offset
Offset immediato [Rn, #<offset_12>] Offset da registro [Rn, Rm]
@ Rd M[Rn <offset_12>]
52
@ Rd M[Rn Rm]
Modo 2: pre-incremento
Pre-incremento immediato [Rn, #<offset_12>]! @ Rn Rn <offset_12> @ Rd M[Rn] Pre-incremento da registro [Rn, Rm]! @ Rn Rn Rm @ Rd M[Rn] Pre-incremento da registro scalato [Rn, Rm, <sop> #<shift_imm>]! @ Rn Rn (Rm <sop> # <shift_imm>) @ Rd M[Rn]
Architettura degli Elaboratori 1
52
2009
Modo 2: post-incremento
Post-incremento immediato [Rn], #<offset_12> @ Rd M[Rn] @ Rn Rn <offset_12> Post-incremento da registro [Rn], Rm @ Rd M[Rn] @ Rn Rn Rm Post-incremento da registro scalato [Rn], Rm, <sop> #<shift_imm> @ Rd M[Rn] @ Rn Rn (Rm <sop> # <shift_imm>)
Architettura degli Elaboratori 1
10
52
2009
Modo 2: esempi
ldr R2, [R0] ldr R1, [R0,#4] ldr R1, [R0], #8 @ R2 M32[R0] @ R1 M32[R0+4] @ R1 M32[R0] @ R0 R0+8
11
52
ldr PC, [PC, R0, LSL #2]@ PC M32[PC+R0*4] strb R7, [R9], #1 @ M8[R9] R7B @ R9 R9+1 @ R0 R0+4 @ M32[R0] R5
2009
12
52
2009
13
52
NOTA BENE: non ha senso parlare di STORE per quantit con segno, perch non c alcuna estensione del segno da effettuare
Architettura degli Elaboratori 1 2009
14
52
start_addr = Rn ; end_addr = Rn + #regs*4 - 4 start_addr = Rn + 4 ; end_addr = Rn + #regs*4 start_addr = Rn - #regs*4 + 4 ; end_addr = Rn start_addr = Rn - #regs*4 ; end_addr = Rn 4 (#regs il numero di registri indicati in <registers>)
DB decrement before
2009
15
52
2009
16
52
2009
17
52 Regole per le istruzioni di elaborazione di dati: tre operandi: due sorgente, uno destinazione tutti gli operandi sono a 32 bit, sia registri che costanti il risultato anch'esso a 32 bit ed posto in un registro
@ r0 = r1 + r2 @ r0 = r0 + r0 = 2*r0
2009
Istruzioni aritmetiche
Addizione: ADD{<cond>} Rd, Rn, <addr_mode1> Sottrazione: SUB{<cond>} Rd, Rn, <addr_mode1> RSB{<cond>} Rd, Rn, <addr_mode1> Moltiplicazione: MUL{<cond>} Rd, Rn, Rs
(attenzione: MUL ha solo operandi nei registri)
18
52
19
52
rsb sta per reverse subtraction C il carry bit del CPSR per impostare i bit di condizione in base al risultato occorre aggiungere il suffisso s al simbolo operativo
Architettura degli Elaboratori 1 2009
20
52
2009
Istruzioni logiche
AND logico: AND{<cond>} Rd, Rn, <addr_mode1> OR logico: ORR{<cond>} Rd, Rn, <addr_mode1> OR esclusivo: EOR{<cond>} Rd, Rn, <addr_mode1> Bit Clear (Rd=Rn AND NOT <addr_mode1>): BIC{<cond>} Rd, Rn, <addr_mode1>
Architettura degli Elaboratori 1
21
52
2009
22
52
bic sta per bit clear : ogni bit 1 nel secondo operando fa azzerare il corrispondente bit nel primo.
Architettura degli Elaboratori 1 2009
23
52
Move (MOV)
Muove un valore tra registri o carica un valore immediato espresso con 12 bit (imm_12=c_8>>2*r_4) MOV{<cond>} Rd, <addr_mode1> MOV MOV MOV MOV MOV MOV MOV R0, R1, R2, R3, R3, R1, PC, #0 #0xFF00 R1 R1, LSL #2 R1, ASR #1 R1, ROR R2 LR @ R0=0 @ R1=65280 @ R2=R1 @ R3=R1*4 @ R3=R1/2 @ R1 ruotato a destra di R2 bit @ ritorno da subroutine
24
52
2009
25
52
2009
Istruzioni di confronto
Compare: aggiorna bit di stato in base al risultato di Rn - <addr_mode1>: CMP{<cond>} Rn, <addr_mode1> Test: aggiorna bit di stato in base al risultato di Rn AND <addr_mode1>: TST{<cond>} Rn, <addr_mode1> Test Equivalence: aggiorna bit di stato in base al risultato di Rn XOR <addr_mode1>: TEQ{<cond>} Rn, <addr_mode1>
Architettura degli Elaboratori 1
26
52
2009
27
52
I risultati delle operazioni (-, +, and, xor) non sono salvati in alcun registro; Solo i bit di condizione (cc) del CPSR sono modificati da queste istruzioni.
2009
28
52
Load : nel registro destinazione viene caricato il contenuto della locazione di memoria indicata dal modo di indirizzamento ldr r0, [r1] @ r0 M32[r1] Store : il contenuto del registro destinazione viene salvato nella locazione di memoria indicata dal modo di indirizzamento str r0, [r1] @ M32[r1] r0
2009
Istruzioni load/store - 2
ldr Rd,<addr_mode2>
risultato di <addr_mode> AAAA AAAA memoria
29
str Rn,<addr_mode2>
52
risultato di <addr_mode> AAAA AAAA memoria
1
AAAA AAAA DDDD DDDD
Rd
DDDD DDDD
Rn
DDDD DDDD
2009
30
52
Carica in Rd16/8 un halfword/byte con zero padding LDR{<cond>}H Rd, <addr_mode3> LDR{<cond>}B Rd, <addr_mode2> Carica un halfword/byte con estensione del segno LDR{<cond>}SH Rd, <addr_mode3> LDR{<cond>}SB Rd, <addr_mode3>
Architettura degli Elaboratori 1 2009
LDR: esempi
LDR LDRB R0, [R1] R0, [R1] @ r0 M32[r1] @ r0 M8[r1] @ r0 ext32(M16[r1]) @ r0 M32[r1-8] @ r0 M32[r1+r2]
31
52
2009
32
52
2009
33
La pseudo istruzione ldr (estensione di ldr) : ldr rn, = valore 52 l'assemblatore espande la pseudo istruzione, ovvero la realizza tramite una o pi istruzioni assembly e aree di supporto: viene creato un dato ausiliario, in un luogo sicuro nelle vicinanze dellistruzione, contenente il valore da caricare e vi si accede tramite un indirizzamento relativo al PC
pc pc+4 pc+8 pc+12 pc+16
ldr r0,=0x47A0
2009
34
52
2009
35
52
2009
36
52
Lassemblatore espande la pseudo istruzione sostituendola con una istruzione add, che somma al PC la distanza (offset) dellindirizzo label: add Rd, pc, #offset Esempio:
pc pc+4 pc+8 pippo: pc+12 R0 pippo R1
Architettura degli Elaboratori 1
DDDD DDDD
DDDD DDDD
2009
Store (STR)
Salva Rn in un word di memoria STR{<cond>}Rn, <addr_mode2> Salva Rn16/8 in un halfword/byte di memoria STR{<cond>}H Rn, <addr_mode3> STR{<cond>}B Rn, <addr_mode2>
37
52
Salva un halfword/byte con estensione del segno: non c; non ha senso estendere il segno in memoria
Architettura degli Elaboratori 1 2009
STR: esempi
STR R0, [R1, #4]! STR R0, [R1], #4 STRB R0, [R1, -R2] STRH R0, [R1, #8] @ preincremento: R1=R1+4, @ poi M32[R1] R0 @ postincremento: @ M32[R1] R0, poi R1=R1+4 @ offset da registro: @ M8[R1-R2] R0B @ offset immediato: @ M18[R1+8] R0W
38
52
2009
39
52
carica un insieme di registri da memoria a partire da M32[Rn] STM<xx> Rn{!}, {lista registri} salva un insieme di registri in memoria (da M32[Rn]) <xx> indica come aggiornare Rn:
IB: Increment Before IA: Increment After DB: Decrement Before DA: Decrement After
Architettura degli Elaboratori 1 2009
LDM/STM e lo stack
4 tipi di stack: FA, FD, EA, ED F E A D = full: SP punta allultimo elemento usato = empty: SP punta al primo elemento libero = ascending: SP cresce con push sullo stack = descending: SP decresce con push sullo stack
LDMIB = LDMED LDMIA = LDMFD LDMDB = LDMEA LDMDA = LDMFA STMIB = STMFA STMIA = STMEA STMDB = STMFD STMDA = STMED
40
52
2009
41
52
LDMDB R12, {R12,SP,PC} @ carica i registri R12, SP, PC @ con M32[R12-12], M32[R12-8], @ e M32[R12-4]
Architettura degli Elaboratori 1 2009
42
52
2009
Esempio: somma
Bisogna ora continuare a copiare gli elementi successivi: copy: copy: adr R1, TABLE1 adr R1, TABLE1 adr R2, TABLE2 adr R2, TABLE2 ldr R0, [R1] ldr R0, [R1] str R0, [R2] str R0, [R2] add R1, R1, #4 add R1, R1, #4 add R2, R2, #4 add R2, R2, #4 ldr R0, [R1] ldr R0, [R1] str R0, [R2] str R0, [R2] @ R1 punta a TABLE1 @ R1 punta a TABLE1 @ R2 punta a TABLE2 @ R2 punta a TABLE2 @ carica il primo valore @ carica il primo valore @ copia il primo valore @ copia il primo valore @ R1 punta al successivo @ R1 punta al successivo @ R2 punta al successivo @ R2 punta al successivo @ carica il secondo valore @ carica il secondo valore @ ... e copialo @ ... e copialo
43
52
Si sono incrementati i due puntatori alle tabelle (i registri R1 e R2) della dimensione degli elementi (word da 4 byte)
Architettura degli Elaboratori 1 2009
Esempio: offset
possibile conglobare l'operazione di incremento dei puntatori nelle istruzioni di load e store, usando lindirizzamento a due componenti (registro+offset immediato): copy: adr R1, TABLE1 @ R1 punta a TABLE1 copy: adr R1, TABLE1 @ R1 punta a TABLE1 adr R2, TABLE2 @ R2 punta a TABLE2 adr R2, TABLE2 @ R2 punta a TABLE2 ldr R0, [R1] @ carica il primo val. ldr R0, [R1] @ carica il primo val. str R0, [R2] @ salva il primo valore str R0, [R2] @ salva il primo valore ldr R0, [R1, #4] @ carica il secondo val. ldr R0, [R1, #4] @ carica il secondo val. str R0, [R2, #4] @ ... e copialo str R0, [R2, #4] @ ... e copialo Usati i puntatori contenuti in R1 e R2, si aggiunta ad essi la dimensione dellelemento (4) in modo che puntino al successivo (con ununica istruzione): ldr R0, [R1, #4] @ R0 M32[R1+4]
Architettura degli Elaboratori 1
44
52
2009
Esempio: pre-incremento
Nell'ultima versione del programma i registri R1 e R2 continuano a puntare all'inizio delle rispettive tabelle; per scorrerle tutte bisogna aumentare, ogni volta, gli offset (8, 12, 16, ...), oppure (meglio) si incrementano i puntatori R1 e R2, usando lindirizzamento con pre-incremento: copy: copy: adr R1, TABLE1 @ R1 punta a TABLE1 adr R1, TABLE1 @ R1 punta a TABLE1 adr R2, TABLE2 @ R2 punta a TABLE2 adr R2, TABLE2 @ R2 punta a TABLE2 ldr R0, [R1] @ carica il primo valore ldr R0, [R1] @ carica il primo valore str R0, [R2] @ salva il primo valore str R0, [R2] @ salva il primo valore ldr R0, [R1, #4]! @carica il secondo val. ldr R0, [R1, #4]! @carica il secondo val. str R0, [R2, #4]!@ ... e copialo str R0, [R2, #4]!@ ... e copialo
45
52
loop: loop:
Il punto esclamativo comporta la pre-modifica del registro: ldr R0, [R1, #4]! @ R1 R1+4, R0 M32[R1]
Architettura degli Elaboratori 1 2009
Esempio: post-incremento
Per scorrere tutta la tabella basta ripetere invariate le ultime due istruzioni; copiato il primo elemento, si pu procedere (loop) con i successivi. possibile uniformare anche la prima operazione, usando l'indirizzamento con post-incremento: copy: copy: loop: loop: adr R1, TABLE1 adr R1, TABLE1 adr R2, TABLE2 adr R2, TABLE2 ldr R0, [R1], #4 ldr R0, [R1], #4 str R0, [R2], #4 str R0, [R2], #4 @ R1 punta a TABLE1 @ R1 punta a TABLE1 @ R2 punta a TABLE2 @ R2 punta a TABLE2 @ carica dal 1.mo vettore @ carica dal 1.mo vettore @ salva nel 2.ndo vettore @ salva nel 2.ndo vettore
46
52
Rispetto al caso precedente, R1 e R2 sono prima usati per accedere agli operandi, e poi vengono incrementati di 4: ldr R0, [R1], #4 @ R0M32[R1], R1R1+4 Servono altre istruzioni per eseguire il loop il numero di volte desiderato (istruzioni di confronto e di salto)
Architettura degli Elaboratori 1 2009
47
52
2009
48
52
@ salta a label1 @ salta a label1 @ salta e salva il PC @ salta e salva il PC @ continua il programma @ continua il programma @ fa qualcosa (subroutine) @ fa qualcosa (subroutine) @ torna a cont @ torna a cont
2009
Condizioni
Estensione mnemonica
49 Significato
Flag di condizione Z=1 Z=0 C=1 C=0 N=1 N=0 V=1 V=0 C=1 e Z=0 C=0 o Z=1 N=V N!=V Z=0 e N=V Z=1 o N!=V Opcode [31:28] 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
EQ NE CS/HS CC/LO MI PL VS VC HI LS GE LT GT LE AL NV
Uguali Non uguali Carry Attivato / Senza segno maggiore o uguale Carry Disattivato / Senza segno minore Negativo Positivo o Zero Overflow Non Overflow Senza segno maggiore Senza segno minore o uguale Con segno maggiore o uguale Con segno minore Con segno maggiore Con segno minore o uguale Sempre ( il default) Mai
52
2009
Istruzioni condizionate
Tutte le istruzioni di elaborazione di dati e di salto possono essere rese condizionate, ovvero la loro effettiva esecuzione pu essere fatta dipendere dallo stato dei bit ZNCV nel CPSR. Per rendere una istruzione condizionata sufficiente apporre come suffisso dell'istruzione il codice della condizione. Esempi: bne label @ salta se non uguale addlt r0, r1, #10 @ somma se minore o uguale movcc R1, #6 @ copia se non c stato riporto
50
52
2009
51
52
@ confronta R1 e R0 @ salta a label2 se R1>R0 (signed) @ controlla i bit 1 e 6 di R1 @ salta alla subroutine errore se @ almeno uno di tali bit 0 @ chiama la funzione di sistema @ numero 16
2009
SWI #0x0F
Completamento dellesempio
Supponiamo che larray da copiare contenga 16 elementi: le istruzioni scritte prima vanno eseguite ripetutamente (loop) 16 volte; allo scopo si pu utilizzare un registro (ad es. R3) come contatore: - vi si inserisce il valore iniziale 16, - lo si decrementa di una unit ad ogni iterazione, - con una instruzione di salto condizionato si riesegue il loop se il contatore diverso zero, altrimenti no: copy: copy: loop: loop: mov R3, #0x10 @ valore iniziale contatore mov R3, #0x10 @ valore iniziale contatore adr R1, TABLE1 @ R1 punta a TABLE1 adr R1, TABLE1 @ R1 punta a TABLE1 adr R2, TABLE2 @ R2 punta a TABLE2 adr R2, TABLE2 @ R2 punta a TABLE2 ldr R0, [R1], #4 @ carica dal primo vettore ldr R0, [R1], #4 @ carica dal primo vettore str R0, [R2], #4 @ salva nel secondo vettore str R0, [R2], #4 @ salva nel secondo vettore subs R3, R3, #1 @ decrementa il contatore subs R3, R3, #1 @ decrementa il contatore bne loop @ salta se non zero bne loop @ salta se non zero
52
52
2009
Fine
03.b