Il linguaggio del calcolatore: linguaggio macchina e linguaggio assembly

Il linguaggio del calcolatore: linguaggio macchina e linguaggio assembly Ingegneria Meccanica e dei Materiali Università degli Studi di Brescia Prof. Massimiliano Giacomin

ORGANIZZAZIONE DEL CALCOLATORE: RICHIAMI Periferia (insieme delle periferiche) sottosistema di ingresso-uscita sottosistema unità centrale-memoria interfaccia di ingresso-uscita interfaccia di ingresso-uscita unità centrale memoria centrale bus di sistema Elementi di Informatica e Programmazione Università di Brescia 2

Programma e dati in memoria: rivisitazione Indirizzo 0 1 0101011110011001 1101011110011111 0111000000011001 1101011100011101 0110011110011001 0101000111011000 1010011110011001 0101111110000000 0101010010011001 0111000000011001 0101000111011000 0101111110000000 MEMORIA zona della memoria che contiene le istruzioni zona della memoria che contiene i dati (numeri, caratteri, testi, immagini ) Istruzioni: come sono codificate? Abbiamo già visto come sono codificati Elementi di Informatica e Programmazione Università di Brescia 3

Il linguaggio macchina (richiami) Linguaggio macchina: costituito da istruzioni macchina, eseguite dalla CPU Ogni CPU ha un proprio linguaggio macchina (ISA Instruction Set Architecture): per esempio, le istruzioni dei processori Intel X86 sono diverse da quelle del processore MIPS - esistono CPU di marca diversa con diversa struttura fisica che risultano compatibili (es. Intel e AMD) Le istruzioni del linguaggio macchina sono costituite da stringhe di bit, suddivise in: Codice operativo à tipo istruzione Operandi à indicano i dati su cui l istruzione opera (sorgenti) e dove memorizzare il risultato (destinazione) operandi Elementi di Informatica e Programmazione Università di Brescia 4

Codice operativo Il processore è in grado di eseguire molti tipi di istruzioni: add, sub, lw, sw, j, beq, Ad ogni tipo di istruzione viene assegnato un codice binario operandi 0000 add 0001 sub 0010 addi 1000 lw 1001 sw Quanti bit sono necessari per il? Dipende dal numero delle istruzioni disponibili! Elementi di Informatica e Programmazione Università di Brescia 5

Operandi Ogni istruzione opera su un certo numero di operandi Ciascun operando può essere: - operando sorgente o destinazione e - immediato, operando, operando in memoria ESEMPI add $r1, $r3, $r4 sorgente sorgente destinazione addi $r1, $r3, 7 sorgente sorgente destinazione Il (add, addi, ) determina: - quanti operandi - di che tipo Elementi di Informatica e Programmazione Università di Brescia 6

ESEMPI add $r1, $r3, $r4 0000 Supponiamo indichi istruzione add Destinazione: Sorgente1: Sorgente2: addi $r1, $r3, 7 0010 Supponiamo indichi istruzione addi Destinazione: Sorgente1: Sorgente2: immediato Elementi di Informatica e Programmazione Università di Brescia 7

Ogni operando può essere: 1) Una costante indicata nel campo dell istruzione (immediato) ESEMPIO addi $r1, $r3, 7 Destinazione: Sorgente1: Sorgente2: immediato 0010 0111 Supponiamo indichi istruzione addi Elementi di Informatica e Programmazione Università di Brescia 8

2) Un dell unità centrale (operando ) $r0 $r1 $r2 $r3 $r4 4 3 5 10 2 0 1 2 3 4 Ognuno è indicato da un numero univoco Per indicare un (in un campo): codifica binaria 0010 indica $r2 quanti bit servono? Elementi di Informatica e Programmazione Università di Brescia 9

Un esempio ipotetico di codifica addi $r1, $r3, 7 \\ $r1 = $r3+7 0010 Destinazione: Sorgente1: Sorgente2: immediato 0001 0011 0111 Supponiamo indichi istruzione addi $r1 $r3 7 Elementi di Informatica e Programmazione Università di Brescia 10

Un altro esempio di codifica (con operandi ) sub $r0, $r1, $r7 \\ $r0 = $r1-$r7 0001 operandi destinazione sorgente1 sorgente2 0000 0001 0111 Supponiamo indichi istruzione sub $r0 $r1 $r7 Elementi di Informatica e Programmazione Università di Brescia 11

Ogni operando può essere anche: 3) Una parola della memoria centrale (operando in memoria) Memoria ESEMPIO lw $r1, $r2, 4 1000 0001 0010 0100 lw $r1 $r2 4 Elementi di Informatica e Programmazione Università di Brescia 12

Linguaggio macchina vs. Linguaggio assembly Codice macchina di una procedura che calcola e stampa la somma dei quadrati degli interi fra 0 e 100 00100111101111011111111111100000 10101111101111110000000000010100 10101111101001000000000000100000 10101111101001010000000000100100 10101111101000000000000000011000 10101111101000000000000000011100 10001111101011100000000000011100 10001111101110000000000000011000 00000001110011100000000000011001 00100101110010000000000000000001 00101001000000010000000001100101 10101111101010000000000000011100 00000000000000000111100000010010 00000011000011111100100000100001 00010100001000001111111111110111 10101111101110010000000000011000 00111100000001000001000000000000 10001111101001010000000000011000 00001100000100000000000011101100 00100100100001000000010000110000 10001111101111110000000000010100 00100111101111010000000000100000 00000011111000000000000000001000 00000000000000000001000000100001 Traduzione: programma chiamato assemblatore Codice assembly di una procedura che calcola e stampa la somma dei quadrati degli interi fra 0 e 100 addiu $sp, $sp, -32 sw $ra, 20($sp) sw $a0, 32($sp) sw $zero, 24($sp) sw $zero, 28($sp) Ciclo: lw $t6, 28($sp) lw $t8, 24($sp) mul $t7, $t6, $t6 addiu $t0, $t6, 1 slti $at, $t0, 101 sw $t0, 28($sp) mflo $t7 addu $t9, $t8, $ta3 bne $at, $zero, Ciclo sw $t9, t8($sp) lui $a0,4096 lw $a1, 24($sp) jal Proc addiu $a0, $a0, 1072 lw $ra, 20($sp) addiu $sp, $sp, 32 jr $ra move $2, $0 Elementi di Informatica e Programmazione Università di Brescia 13

Il linguaggio assembly Usare direttamente il formato binario per scrivere (e leggere) programmi sarebbe impraticabile si usa il linguaggio assembly (o assembler) Il linguaggio assembly è la rappresentazione simbolica della codifica binaria usata dal calcolatore (linguaggio macchina) L assembly è più leggibile: utilizza codici operativi simbolici (anziché bit) che richiamano direttamente il significato di una istruzione (p.es. ADD al posto di 0001) permette l utilizzo di etichette per identificare gli indirizzi di parole di memoria che contengono istruzioni (e anche dati) Assemblatore: traduce linguaggio assembler in linguaggio macchina Elementi di Informatica e Programmazione Università di Brescia 14

1. Pull along perforation to separate card 2. Fold bottom side (columns 3 and 4) together Jump Register jr R PC=R[rs] 0 / 08 hex R[rt]={24 b0,m[r[rs] Load Byte Unsigned lbu I 24 +SignExtImm](7:0)} (2) hex Load Halfword R[rt]={16 b0,m[r[rs] lhu I 25 Unsigned +SignExtImm](15:0)} (2) hex 1 ARITHMETIC Load Linked CORE ll INSTRUCTION I R[rt] = SET M[R[rs]+SignExtImm] (2,7) 2 OPCODE 30 hex Load Upper Imm. lui I R[rt] = {imm, 16 b0} / FMT f M I P S hex /FT Reference Data FOR- / FUNCT Load Word lw I R[rt] = M[R[rs]+SignExtImm] (2) 23 NAME, MNEMONIC MAT OPERATION (Hex) hex CORE INSTRUCTION SET OPCODE Branch Nor On FP True bc1t nor FIRif(FPcond)PC=PC+4+BranchAddr R[rd] = ~ (R[rs] R[rt]) (4) 011/8/1/-- / 27 UN ESEMPIO hex FOR- / FUNCT Branch Or On FP False bc1f or FIRif(!FPcond)PC=PC+4+BranchAddr(4) R[rd] = R[rs] R[rt] 011/8/0/-- / 25 hex NAME, MNEMONIC MAT OPERATION (in Verilog) (Hex) Divide Or Immediate div ori R I Lo=R[rs]/R[rt]; R[rt] = ZeroExtImm Hi=R[rs]%R[rt] (3) 0/--/--/1a d hex Add add R R[rd] = R[rs] + R[rt] (1) 0 / 20 Divide Unsigned divu R Lo=R[rs]/R[rt]; Hi=R[rs]%R[rt] (6) 0/--/--/1b hex Set Less Than slt R R[rd] = (R[rs] < R[rt])? 1 : 0 0 / 2a FP Add Single add.s FR F[fd ]= F[fs] + F[ft] 11/10/--/0 hex Add Immediate addi I R[rt] = R[rs] + SignExtImm (1,2) 8 hex FP Set Add Less Than Imm. slti I {F[fd],F[fd+1]} R[rt] = (R[rs] < = SignExtImm)? {F[fs],F[fs+1]} 1 : + 0 (2) a hex Add Imm. Unsigned addiu I R[rt] = R[rs] + SignExtImm (2) 9 hex Double Set Less Than Imm. add.d FR R[rt] = (R[rs] < SignExtImm) 11/11/--/0 sltiu I {F[ft],F[ft+1]} b Add Unsigned addu R R[rd] = R[rs] + R[rt] 0 / 21 hex FP Compare Unsigned Single c.x.s* FR FPcond = (F[fs]? 1 op : 0 F[ft])? 1 : 0 (2,6) hex 11/10/--/y FP Set Compare Less Than Unsig. sltu R And and R R[rd] = R[rs] & R[rt] 0 / 24 FPcond R[rd] = (R[rs] ({F[fs],F[fs+1]} < R[rt])? 1 op : 0 (6) 0 / 2b hex hex c.x.d* FR 11/11/--/y Double Shift Left Logical sll R R[rd] = R[rt] {F[ft],F[ft+1]}) << shamt? 1 : 0 0 / 00 hex And Immediate andi I R[rt] = R[rs] & ZeroExtImm (3) c hex * (x is eq, lt, or le) (op is ==, <, or <=) ( y is 32, 3c, or 3e) Shift Right Logical srl R R[rd] = R[rt] >> shamt 0 / 02 if(r[rs]==r[rt]) FP Divide Single div.s FR F[fd] = F[fs] / F[ft] 11/10/--/3 hex Branch On Equal beq I 4 PC=PC+4+BranchAddr (4) hex FP Divide {F[fd],F[fd+1]} M[R[rs]+SignExtImm](7:0) = {F[fs],F[fs+1]} = Store Byte sb / div.d FR I 28 R[rt](7:0) (2) 11/11/--/3 hex if(r[rs]!=r[rt]) Double {F[ft],F[ft+1]} Branch On Not Equal bne I 5 PC=PC+4+BranchAddr (4) hex FP Multiply Single mul.s FR F[fd] M[R[rs]+SignExtImm] = F[fs] * F[ft] = R[rt]; Store Conditional sc I 11/10/--/2 38 R[rt] = (atomic)? 1 : 0 (2,7) hex Jump j J PC=JumpAddr (5) 2 FP Multiply {F[fd],F[fd+1]} = {F[fs],F[fs+1]} * hex mul.d FR 11/11/--/2 Double M[R[rs]+SignExtImm](15:0) {F[ft],F[ft+1]} = Store Halfword sh I 29 Jump And Link jal J R[31]=PC+8;PC=JumpAddr (5) 3 hex R[rt](15:0) (2) hex FP Subtract Single sub.s FR F[fd]=F[fs] - F[ft] 11/10/--/1 Jump Register jr R PC=R[rs] 0 / 08 hex FP Store Subtract Word sw I {F[fd],F[fd+1]} M[R[rs]+SignExtImm] = {F[fs],F[fs+1]} = R[rt] - (2) 2b hex sub.d FR 11/11/--/1 R[rt]={24 b0,m[r[rs] Double Subtract sub R R[rd] = R[rs] - R[rt] {F[ft],F[ft+1]} (1) 0 / 22 hex Load Byte Unsigned lbu I 24 +SignExtImm](7:0)} (2) hex Load Subtract FP Single Unsigned lwc1 subu I RF[rt]=M[R[rs]+SignExtImm] R[rd] = - R[rt] (2) 31/--/--/-- 0 / 23 hex Load Halfword R[rt]={16 b0,m[r[rs] Load FP F[rt]=M[R[rs]+SignExtImm]; (2) lhu I 25 ldc1 (1) May I cause overflow exception 35/--/--/-- Unsigned +SignExtImm](15:0)} (2) hex Double (2) SignExtImm F[rt+1]=M[R[rs]+SignExtImm+4] = { 16{immediate[15]}, immediate } Move From Hi mfhi (3) ZeroExtImm R R[rd] = { Hi 16{1b 0}, immediate } 0 /--/--/10 Load Linked ll I R[rt] = M[R[rs]+SignExtImm] (2,7) 30 hex Move From Lo mflo (4) BranchAddr R R[rd] = { Lo 14{immediate[15]}, immediate, 2 b0 0 /--/--/12 } Load Upper Imm. lui I R[rt] = {imm, 16 b0} f hex Move From Control mfc0 (5) JumpAddr R R[rd] = = { CR[rs] PC+4[31:28], address, 2 b0 } 10 /0/--/0 Load Word lw I R[rt] = M[R[rs]+SignExtImm] (2) 23 hex Multiply mult (6) Operands R {Hi,Lo} considered = R[rs] unsigned * R[rt] numbers (vs. 2 s comp.) 0/--/--/18 (7) Atomic test&set pair; R[rt] = 1 if pair atomic, 0 if not atomic Nor nor R R[rd] = ~ (R[rs] R[rt]) 0 / 27 Multiply Unsigned multu R {Hi,Lo} = R[rs] * R[rt] (6) 0/--/--/19 hex Shift BASIC Right INSTRUCTION Arith. sra FORMATS R R[rd] = R[rt] >>> shamt 0/--/--/3 Or or R R[rd] = R[rs] R[rt] 0 / 25 hex Store FP RSingle opcodeswc1 rsi M[R[rs]+SignExtImm] rt rd = F[rt] shamt (2) 39/--/--/-- funct Or Immediate ori I R[rt] = R[rs] ZeroExtImm (3) d hex Store FP 31 26 25 21 M[R[rs]+SignExtImm] 20 16 15 11 = 10 F[rt]; 6(2) 5 0 sdc1 I 3d/--/--/-- Set Less Than slt R R[rd] = (R[rs] < R[rt])? 1 : 0 0 / 2a hex Double I opcode rs M[R[rs]+SignExtImm+4] rt = immediate F[rt+1] Set Less Than Imm. slti I R[rt] = (R[rs] < SignExtImm)? 1 : 0 (2) a hex Set Less Than Imm. R[rt] = (R[rs] < SignExtImm) sltiu I b Unsigned? 1 : 0 (2,6) hex Set Less Than Unsig. sltu R R[rd] = (R[rs] < R[rt])? 1 : 0 (6) 0 / 2b hex Shift Left Logical sll R R[rd] = R[rt] << shamt 0 / 00 hex MIPS Reference Data Card ( Green Card ) 1. Pull along perforation to separate card 2. F Shift Right Logical srl R R[rd] = R[rt] >> shamt 0 / 02 hex Store Byte sb I M[R[rs]+SignExtImm](7:0) = R[rt](7:0) (2) 28 hex 31 26 25 21 20 16 15 0 Elementi di Informatica e Programmazione Università di Brescia 15 PSEUDOINSTRUCTION SET NAME MNEMONIC OPERATION Branch Less Than blt if(r[rs]<r[rt]) PC = Label FP Subtract Double Load FP Single Load FP Double Move From Hi Move From Lo Move From Con Multiply Multiply Unsign Shift Right Arith Store FP Single Store FP Double FLOATING-PO FR FI 31 31 opc opc PSEUDOINST N Branch Les Branch Gre Branch Les Branch Gre Load Imme Move REGISTER NA NAME $zero $at $v0-$v1 $a0-$a3 $t0-$t7 $s0-$s7 $t8-$t9 $k0-$k1 $gp $sp 31 26 25 21 20 16 15 0 FLOATING-POINT INSTRUCTION FORMATS $fp J opcode address $ra FR 31 opcode 26 25 fmt ft fs fd funct 0 Copyright 31 2009 by 26 Elsevier, 25 Inc., 21 All 20 rights reserved. 16 15 From 11Patterson 10 and 6 5Hennessy, Computer 0 Organizat FI opcode fmt ft immediate