ESTRUCTURA DE COMPUTADORS - I

MODUL I: ESTUDI DEL NIVELL LM (386) I LA (TASM)

Tema 1: Visió general

Tema 2: Tipus de dades i instruccions.

Tema 3: Modes d'adreçament.

Tema 4: Subrutines.

MODUL II: SUBSISTEMA D'E/S

Tema 5: Perifèrics i controladors

Tema 6: Sincronització de les operacions d'E/S

Tema 7: Transferencies per DMA.

MODUL III: SUBSISTEMA DE MEMORIA

Tema 8: Introducció a la jerarquia de la memòria.

Tema 9: Memòria virtual.

TEMA 1: VISIÓ GENERAL

EVOLUCIÓ DE LA FAMILIA X86

En 1978 va apareixer el 8086. Això va marcar el començament dels microprocessadors com auténtics ordinadors y també on comença la família 86. El 8086 és un processador de 16 bits.

En 1982 es va presntar el 80286 que és un superconjunt de l'arquitectura del 8086. Aquest és de 16 bits.

En 1985 es va presentar el 80386. Aquest proporciona dues millores: mes operacions i els tipus de dades poden ser de 32 bits.

En 1989 es va presentar el 80486 que mante les instruccions del 386 però millorat en la part tècnica al igual que el Pentium del 1993, i el Pentium-Pro del 1995.

En 1997 apareix el Pentium-MMX amb el qual s'introdueixen noves instrucciones dedicades a Multimedia.

MODEL DE PROGRAMACIÓ

El model de programació defineix la visió que té el programador de LM de la memòria del computador.

La memória és la font i destí principal de tota l'informació. La memória fisica del 386 està organitzada en una seqüencia de 8 bits (bytes). Cada byate es assignat a una adreça que pot estar entre 0 i el màxim 232-1 (4 gigabytes). El model de l'organització de la memòria pot ser:

-Model linial: la memòria es considera simplement com una taula seqüèncial de bytes, cada un dels quals te una única direcció. El punter en aquest tipus de memòria és un nombre natural de 32-bits.

-Model segmentat: es divideix l'espai de la memòria en una o més regions linels separades, denominades segments. Per tant en aquest cas una direcció de memòria es compon de dues parts: selector de segment (16 bits), que identifica el principi del segment que conté la dada, i el desplaçament (32 bits), que proporciona un desplaçament que identifica a un únic byte dintre d'aquest segment (offset). Aquestes dues parts deuen ser especificades per una instrucció que contingui un operan de memòria. Aquest tipus de memòria segmentada permet fins a 16383 segments posibles. Per compatibilitat amb els anteriors processadors s'utilitzen només 16 bits pel selector de segment i 16 pel desplaçament. En aquest cas el càlcul de l'adreça física és:

sel. seg*16 + desplaçament

Si un tipus de dades té més de 32 bits per la seva representació, llavors s'utilitzen bytes contigus. El byte de menys pes va a l'adreça més baixa o a l'inreves.

Una paraula-word- te dos bytes (16 bits) i una doble paraula-dword- 4 bytes (32 bytes).

El 386 te tres modes de processament:

-Mode protegit: és elmode natural de 32-bit del 386. En aquest mode totes le sintruccions i caracterísques són posibles.

-Mode adreçament real (mode real): en aquest mode el 386 apareix als programadors com un ràpid 8086amb algunes noves instruccions.

-Mode virtual 8086 (mode V86): és un mode dinàmic en el sentit que el processador pot cambiar entre V86 i el mode protegit. La CPU entra en el mode V86 des de el mode protegit per executar un programa del 8086.

REGISTRES

El 386 conté 16 registres dividits en tres grups:

-Propòsit general: 8 registres de 32 bits per operacions aritmétiques i lògiques i per registres base e index de la direcció de memòria.

-Segment: 6 registres de 16 bits que adrecen els segments de memòria. Cada registre proporciona un accés directe a un segment de memória cada vegada. Contenen els selectors de segment.

-Control: 2 registres de 32 bits de control del processador

REGISTRES GENERALS

8 registres de 32 bits usats per fer operacions aritmétiques i també per formar direccions de memória. Aquest 8 registres són: EAX, ECX, EDX, EBX, ESP, EBP, ESI i EDI.

Als 16 bits de menys pes d'aquests registres es pot accedir de forma independent com registres e 16 bts, i es denominen AX, CX, DX, BX, SP, BP, SI i DI. Aquests registres coincideixen amb els vuit registres generals del 8086 i 286 i proporcionen la compatibilitat entre els i els 386.

Les meitats inferior i superior dels registres X es pot accedir independenment com registres de 8bits. El nom es forma amb la lletra del registre i afegint H o L. L si està format pels 8 bits de menys pes i H si està format pels 8 bits de mes pes.

REGISTRES DE CONTROL DE PROCÉS

2 registres controlen el funcionament del procesador 80386: EIP, el registre punter d'instruccions i EFLAG, el registre d'estat del processador i d'indicador de control.

-EIP: 32 bits i apunta a la instrucció del processador que es va a executar a continuació. Busca la instrucció apuntada pel registre EIP, incrementa el contingut de EIP i després executa la instrucció. L'increment deixa al EIP apuntant a la següent instrucció almacenada a memòria. El registre de 16 IP esta compost pels 16 bits de menys pes del registre EIP.

-EFLAGS: 32 bits i conté diversos bits indicadors d'estat i control. El registre de 16 bits del EFLAGS es deomina FLAGS i pot ser tratat com una unitat. Això és util de cara a la compatibilitat amb el 8086 i 286.

-Indicadors d'estat aritmétic:

CF indicador del carry. 1 si hi ha carry i 0 si no hi ha

PF indicador de paritat. Indica la paritat dels 8 bits inferiors del resultat

ZF indicador de zero. Es posa a 1 si el resultat és 0.

SF indicador e signe. ES posa amb un valor igual al bit més significatiu del resultat.

OF indicador de desbordament (overflow). Es posa a 1 si el resultat d'una operació es massa gran com per ser representat oper un enter en Ca2.

-Indicadors de control del processador:

TF indicadpr de habilitació de trap controla la generació de interrupcions pas-a-pas.

IF indicador d'habilitació d'interrupcions habilita el reconeixement d'interrupcions xternes que arriben a través d'una patilla del processador.

DF indicador de direcció que determina si les instruccions de cadena incrementarán o decreixeran.

REGISTRES DE SEGMENT

El 386 te 6 registres de segment de 16 bits que direccionen segments de memòria. Aquests són: ES, CS, SS, DS, FS, GS.

Per accedir a les dades dins d'un segment donat, un programa ha de cargar un dels registres de segment amb un valor especial per identificar el segment. Aquest valor especial és el selector.

Aquests registres permeten al programador la flexibilitat d'escogir entre varis models d'organització de memòria. Aquests registres proporcionen acces fins a sis segments diferents en qualsevol punt del programa.

El segment adreçat pel registre CS en qualsevol moment, es denomina segment de codi actual. El segment que conté la seqüència d'instruccions és conegut com el segment de codi. El 386 exeuta totes les instruccions a partir d'aquest segment de codi.

El segment adreçat pel registre SS és el registre d la pila. Les operacions de pila utilitzen una pila de programa, continguda dins el segment adreçat per SS. El cim o cap d'aquesta pila es troba en el desplaçament indicat pel contingut del registre ESP. La direcció del cim de la pila és SS:[ESP].

El registre DS és el registre del segment de dades principal, ja que és el registre de segment per defecte per referències que no siguin a la pila.

GESTIÓ DE LA PILA

Una pila és una estructura de dades que és caracteritza per l'ordre d'accés als seus elements, soporta un mecanisme d'assiganció de tipus LIFO (Last IN, First Out: últim en entrar, primer en sortir). La pila s'utilitzará com a magatzem temporal d'informació.

Laopració PUSH afegeix un nou element a la pila, mentre que POP elimina l'últim element introduit en la pila, aquestes operacions es referencien implicitament al registre de segment SS i al registre general ESP. La pila es troba en el segment de memoria direccionada pel registre SS. El registre ESP conté el desplaçament dins d'aquest segment del cim de la pila. La direcció SS:[ESP] apunta el cim actual de la pila.

En el 80386, la pila creix fins direccions inferiors i cada element te 4 bytes (32 bits) d'amplada. Quan s'introdueix un element en la pila (PUSH), primer s'incremente ESP en 2 o 4 i després s'escriu el nou element en la posició de memória adreçada. Per extreu-re un element de la pila (POP), es recupera l'element llegint-lo en la posició de memória adreçada i després s'incrementa ESP en 2 o 4. La mida dels operands de la pila han de ser de 16 o 32 bits però no de 8 bits.

ESQUEMA BÀSIC D'UN PROGRAMA EN ASSAMBLADOR

.model large

.386

.stack “mida” ;Per especificar el segment de la pila, la mida en bits.

.data ;segment de dades.

“declaració de les dades”

.codi ;segment del codi

.startup

“instruccions del programa”

.exit

end

Startup: inicialitza els registres SS a la posició inicial de la ila i ESP a la mida de la pila. Posa DS a la posició inicial del segment de dades i CS i EIP es posen a la primera posició del programa per executar la primera instrucció.

Exit: retorna el control al sistema operatiu.

INSTRUCCIONS

-Moviment de dades:

MOV destí, font ;agafa l'operand font i el copia a l'operand destí.

XCHG op1, op2 ;fa un intercanvi entre operands.

PUSH op ;decrementa ESP , MEM[SS:ESP] <- op.

POP op :op <- MEM[SS:ESP], incremnta ESP.

-Aritmétiques:

ADD op1, op2 ;es suma op1+op2 i es guarda a op1.

-Lògiques:

AND op1, op2 ;es fa el producte lògic i es guarda a op1.

OR op1, op2 ;es fa la suma lògica i es guarda a op1.

XOR op1, op2 ;es fa operació o exclusiva i es guarda a op1.

NOT op ;es fa la negació del operand i es guarda a op.

-Transferència de control:

.JMP op ;salt incondicional, op és l'etiqueta a on es vo anar.

El salt condicional es compost per dues instruccions: CMP que compara dos operands i:

JA ;salta si mé gran

JAE ;salta si més gran o igual

JB ;salta si més petit

JBE ;salta si més petit o igual

JE ;salta si igual

JNE ;salta si no igual

MODES D'ADREÇAMENT EN LA

Especifiquem l'algorisme per saber on està emmagatzemat un operand.

MOV EAX, EBX ;mode registre (operand a un registre).

MOV AX, 1 ;mode inmediat (operand és a la propia instrucció)

MOV AL, D ;mode inmediat: D és una constant

MOV AX, dada2 ;mode memoria (despl): dad2 és una etiqueta.

MOV EAX, [EBX] ;mode memòria (base), registre indirecte.

MOV EAX, [EBX+ESI];mode memòria (base+index)

MOV EAX,VAR ;mode memòria absolut (s'especifica directament l'adreça): VAR és una etiqueta del segment data.

Característiques de les instruccions

El 386 és una màquina de 2 operands, es a dir, com a màxim es poden posar 2 operands directament. Un operand és font i destí a l'hora.

Excepcions:

-D'1 operand: MULT op; aquí s'agafa com segon operand el del registre EAX

-De 3 operands: IMUL opd, opf1, opf2

No es poden agafar dos operands de memòria a l'hora.

PROGRAMA EXEMPLE

Fa la suma dels elements d'un vector.

.mode large

.386

N EQU 10 ;declaració de constants (nom EQU valor

.stack 100h

.data

a dd 1,3,4,-7,0ah,101010b,3,2,4,-1 ;declaració d'un vector

res dd ? ;reserva espai per una variable

.code

.startup

mov EDI, 0 ; mou 0 a EDI

mov EAX, EDI ; mou a EAX el contingut de EDI

bucle: add EAX, a[EDI]

add edi, 4

cmp EDI, N*4

jb bucle

.exit

end

PROCESSOS D'ASSAMBLATGE, MUNTATGE, CÀRREGA

Assamblatge: traducció del llenguatge assamblador a llenguatge màquina. D'un fitxer amb xtensió .ASM es crea un amb extensió .OBJ que conte el codi del programa en LM. Aquest procès es fa gràcies al Turbo Assambler (TASM)

Muntatge: generar un fitxer executable de l'aplicació a partir del s diferents fitxer amb extensió .OBJ de que consti el programa. Reubicació: cambia l'adreça de memòria de les dades (segment de dades) si hi ha més d'un fitxer, amb el segment de dades, per muntar.

Càrrega: carregar a memòria el fitxer .EXE i inicialitzar el startup del programa. També hi ha reubicació però només de les direccions base dels segments del programa.

TEMA 2: TIPUS DE DADES I INSTRUCCIONS

NATURALS

Els naturalks es representen en binari. El rang d'un nombre natural de 8 bits és 0-255; 16 bits de 0 fins 65535; de 32 bits és de 232-1. La fòrmula general per trobar el rang és 0..2n-1.

Amb aquests tipus de dades és pot produir el carry que indica si l'ultima instrucció s'ha emmagatzemat correctament, el que indica és si el resultat de la operació és massa gran per representar-la amb un nombre determinat de bits. També hi pot haver Borrow (carry però quan es resta). El borrow i el carry és guarden al CF

INSTRUCCIONS

Aritmètiques:

ADD destí, font ; actualitza l'operand destí amb la suma del destí amb font i font no pot ser un inmediat

SUB d, f ;fa la resta de d menys f i el resultat és guarda a f.

MUL op ;fa una multiplicació sense signe. La seva acció depen del tamany del seu operand com segueix:

-Operand (8 bits) multiplicat per AL, el resultat es guarda a AX.

-Operand (16 bits) multiplicat per AX, el resultat es guarda a DX_AX. On DX conté els 16 bits de mes pes de la multiplicació i AX els de menys pes.

-Operand (32 bits) multiplicat per EAX el resultat es guarda a EDX_EAX. On EDX conté els 32 bits de mmes pes del resultat de la multiplicació.

DIV op ;fa una divisió sense signe. El divident esta implicit, només es dona el divisor com operand. El tamany del divisor determinar quins registres s'utilitzen:

Tamany	Dividendo	Divisor	Quocient	Reste
byte	AX	r/m 8	AL	AH
word	DX_AX	r/m 16	AX	DX
dword	EDX_EAX	r/m 32	EAX	EDX

INC op ;suma 1 al operand. Això no afecta al CF.

DEC op ;resta 1 al operand i no modifica el CF.

Encara que el 386 sigui un processador de 32 bits pot realitzar sumes i restes de 64 bits. Primer suma o resta els primers 32 bits de menys pes, es guarda el carry i despres es suma el carry a un dels blocs de 32 bits i despres es suma o resta el bloc que queda. Per fer la suma amb carry s'utilitza la instrucció:

ADC d, f ;fa la suma de l'operand d amb f i amb el carry i el resultat el guarda a l'operand d.

SBB d, f ;fa la resta de l'operand destí (d) amb l'operand font més el carry (d <- d- (f+CF)).

Comparació:

CMP op1,op2;fa la resta de op1-op2 però no guarda el resultat, només canvia els flags.

Jxx etiq ;fa un salt segons una condició:

JA ;salta si mé gran (CF=0 i ZF=0).

JAE ;salta si més gran o igual (CF=0).

JB ;salta si més petit (CF=1).

JBE ;salta si més petit o igual (CF=1 o ZF=1)

JE ;salta si igual (ZF=1)

JNE ;salta si no igual (ZF=0)

Conversió de mida: cambia la mida dels naturals, només es pot incrementar de 8 a 16, de 8 a 32 o de 16 a 32 bits. Les instruccions són:

MOVZX d, f ;llegeix l'operand (memòria o registre) i l'incrementa els bits fent una extensió de ceros fins arribar a la mida desitjada.

ENTERS

Els nombre enters es representan en complement a 2. El signe es localitza en bit 7 en un byte, en el 15 en una paraula, i en el 31 in una dobleparaula. Si el bit de signe es 0 llavors el nombre és positiu i si és 1 el nombre és negatiu.

El rang de valors és (-2n-1..+2n-1-1),per 8 bits és desde -128 fins 127, per 16 bits és desde -32768 fins 32767.

El complement a 2 te les característiques de que s'utilitza el mateix algorisme per sumar i restar enters que per naturals i que la resta es pot implementar com una suma (cambiant el sustarend a Ca2 i es suma al minuend).

Amb el Ca2 es pot produir l'Overflow que ens diu si el resultat emmgatzemat és correcte. L'overflow es pot produir quan es sumen nombres del mateix signe i el resultat es de diferent signe i si es resten dos nombres i el signe del resultat és igual al signe del sustret (sustraendo).

El bit de carry que s'obté en la usma és el complementari del que s'obté en la resta. El bit de carry a CF és el que s'obté en la resta real.

INSTRUCCIONS

Aritmètiques:

ADD d, f ; actualitza l'operand destí amb la suma del destí amb font i font no pot ser un inmediat

SUB d, f ;fa la resta de d menys f i el resultat és guarda a f.

IMUL op ;fa el mateix que MUL op però te en compte el signe.

IMUL d, f ;fa la multiplicació de d per f i es guarda a d tenint en compte el signe. EL nombre de bits del resultat és el nombre de bits de l'operand font.

IMUL d, f1, f2 ;fa la multiplicació de f1*f2 i el resultat es guarda a d, i tenint en compte l'anteriorment dit.

Composició:

CMP op1,op2;fa la resta de op1-op2 però no guarda el resultat, només canvia els flags.

Jxx etiq ;fa un salt segons una condició:

JL ;salta si més petit (SF <> OF).

JLE ;salta si més petit o igual (ZF=1 i SF<>OF).

JG ;salta si més gran (ZF=0 i SF=OF).

JGE ;salta si igual (SF=OF).

JE ;salta si igual (ZF=1).

JNE ;salta si no igual (ZF=0).

Conversió de mida:

MOVSX d, f ;llegeix l'operand (memòria o registre) i l'incrementa els bits fent una extensió de signe fins arribar a la mida desitjada. L'extensió de signe es fa replicant el bit de mes pes fins a arribar a la mida desitjada.

CARÀCTERS

La seva representació és en codi ASCII de 7 (Standard) bits amb els quals es poden representar 128 caràcters. Els 7 bits es guarden als 7 bits de menys pes d'un byte i en el 8 bit es posa un. Aquest vuitè bit tambè es pot utilitzar donant la formació de caràcters semigràfics i caràcters especifics per a cada llengua.

Les operacions que es poden realitzar amb els caràcters són:

-l'accés, per veure el contingut i

- la comparació.

Els caràcters a l'hora de declarar-lo es declaren entre cometes simples. Sempre s'ha de reserva un byte de memòria ja que és la mida que ocupen.

CAR DB `c'

Les instruccions que es poden realitzar amb els caràcters son MOV i CMP que funcionen igual que en els tipus anteriors.

MOV CAR, '0' ;canvia el valor de CAR pel dígit 0

CMP CAR, `a' ;compara si CAR és la lletra a

BOOLEANS

Per a la seva reprsentació només es necesita un bit el qual és 0 si el resultat és fals i 1 si és cert, però en realitat s'utilitza un byte perque és més comode, ja que és el mínim al que es pot accedir a memòria. En aquest cas quan tots els bits són 0 el resultat és fals i si hi ha algú bit amb el valor lògic 1 el byte ja es considera fals.

Per a la declaració de la variables només s'ha de reserva un byte de memòria i donar-li el valor lògic 1 o 0.

INSTRUCCIONS

Lògiques:

OR d, f ;fa la suma lògica bt a bit de d i f i es guarda a d. S'interpreta els bit per separat.

AND d, f ;fa el producte lògic i es guarda a d.

XOR d, f ;fa la o exclusiva entre els dos operands.

NOT op ;inverteix l'operand.

Desplaçament: els bits dels bytes, word o doublewords poden ser desplaçades aritmèticament o logicament. Depenen dels valor especificat els bits poden ser desplaçament un màxim de 31 llocs.

Una instrucció de desplaçament pot especificar el nombre de bits a desplaçament de tres modes. Una forma implicita especifica que es desplaça un sol bit. La segona forma especifica el valor com un valor inmediat. La tercera forma especifica el valor com el valor contingut al registre CL

SAL/SHL op, n;desplaçament de n bits a l'esquerra, n pot ser un inmediat o un registre (però només el CL). Per la dreta s'introdueixen tants ceros com bits es vulguin desplaçar. Tots els bits de l'esquerra es perden excepte l'últim que es guarda al carry flag (CF).

SAR op, n ;desplaçament de n bits cap a la dreta. Manté el signe de l'operand duplicant el bit de l'esquerra tantes vegades com el desplaçament.

SHR op, n ;desplaçament de n bits cap a la dreta però sempre posa un 0 als bits de l'esquerra desplaçats.

Aquestes instruccions es poden utilitzar com instruccions aritmétiques ja que SAL/SHL equival a la multiplicació del operand per 2n, SAR equival a la divisió de l'operand per 2n per nombres enters i SHR equival a la divisió per 2n per nombres naturals.

Rotació: els bits rotats fora d'un operand no es perden com al desplaçament, sino que es posen a l'altre extrem de l'operand. Rotar nomes afecta als flags carry i al overflow. CF pot actuar com una extensió de l'operand permitin que un bit sigui evaluat per un salt condicional. CF sempre conté el valor de l'últim bit rotat fora, encara que la instrucció no l'utilitzi com una extensió de l'operand.

ROL op, n ;rota a l'esquerra n bits. Per a cada rotació, el bit de mes pes que existeix de l'esuqerra de l'operand retorna a la dreta per ser el bit de menys pes.

ROR op, n ;rota a la dreta n bits. El bit de menys pes de l'operand es converteix en el bt de més pes.

RCL op, n ;rota a l'esquerra n bits. Aquesta instrucció utilitza el CF com el bit de més pes. Cada bit de més pes que existeix es mou al CF i el CF reotrna a l'operand el bit de menys pes en la següent rotació.

RCR op, n ;rota a la dreta n bits utilitzant el CF de forma inversa al RCL.

Comparació:

TEST op1, op2;realitza la funció lògica AND dels dos operands però aquesta operació no guarda el resultat com AND. Aquesta instrucció evalua multiples bits.

BT op, n ;fa la mateixa funció que TEST però en canvi només ho fa d'un bit.

JC ; salta si el carry està activat (CF=1).

JNC ; salta si el arry no està activat (CF=0).

JO ; salta si l'overflow està activat (OF=1).

JNC ; salta si l'overflow no està activat (OF=0).

PUNTERS

Un punter és en realitat una adreça de memòria per tant per si mateix no te sentit i sempre serà u npunter a un enter, natural, caràcter, booleans, vectors o matrius. Un punter és el desplaçament dintre d'un segment.

S'utilitzen quan la dada a que apunta pot canviar d'adreça durant l'execució del programa o si no se sap l'adreça de la dada en temps de programació.

El punters utilitzen 32 bits per a la seva representació: els 16 de més pes per indicar el segment i els 16 de menys pes per indicar el desplaçament.

MODE D'ADREÇAMENT

-Registre indirecte: aquet mode d'adreçament es composa per indicar l'adreça continguda en un registre. Per indicar això el registre es posa entre corxets.

MOV EAX, [EBX] ;EAX <-- MEM[DS: EBX]

Les operacions que es poden realitzar amb els punters són la inicialització i l'accès al punter.

La inicialització es pot fer de manera estàtica (al començament en el segment de dades) o dinàmica (durant el transcurs del programa).

Mode estàtic:

.data

PUNTER DD VAR1 ;punter que apunta a la variable VAR1.

Mode dinàmic:

MOV PUNTER, WORD PTR OFFSET VAR2

MOV PUNTER+2, WORD PTR SEG VAR2

WORD PTR el que provoca és forçar a que l'inmediat sigui de 16 bits, si en lloc de word es poses DoubleWord serien 32 i si fos byte serien 8 bits.

L'offset indica a l'instrucció obtenir el desplaçament de l'adreça que indica la variable o etiqueta. Seg indica a la instrucció obtenir el segment a que pertany l'etiqueta.

Aquestes dues instruccions es podrien substituir per la instrucció LEA:

LEA registre, memòria ;Calcular l'adreça efectiva i la guarda en un registre especial. AX <- @ (VAR2) " offset (var2).

LEA AX, VAR2

L'accès al punter es fa amb la instrucció LES, LDS, LFS, LGS. Les instruccions LDS, LFS, LGS realitzen la mateixa operació que LES però guardant el selector de segment als registres DS, FS o GS.

LES registre, punter ;transfereix una variable punter desde l'operand font al registre ES. Carga el ES amb el selector de segment indicat pel punetr i carga el desplaçament del punter en el registre especificat.

LES AX, PUNTER ;AX ! MEM [DS: PUNTER] (desplaçament).

ES ! MEM [DS: PUNTER+2] (selcetor de egment).

VECTORS I TAULES

Aquests dos tipus són estructurats i homogenis i poden estar formats per tipus simples, vectors o matrius.

Els vectors s'emmagatzemen a memòria un darrere l'altre ocupant els bytes especificats a la declaració de variables.

L'accès als vectors es pot fer de dues formes diferents:

Suposant v: array [li..ls] of T

Accès aleatori @v[i]= adreça_base (v)+ (i-li)*bytes (T).

Accès seqüèncial: @v[i]= @v[i-1]+ bytes (T).

Per calcular l'accés es pot utilitzar el mode d'adreçament indexat el qual consisteix en:

v: array [-3..3] of integer (*enter de 32 bits*)

a[i] := 4

MOV v+12[EAX*4], 4 ;l'unic nombre pel qual es pot mutiplicar es per 1, 2 o 4.

Les matrius s'emmagatzemen de forma similar als vectors pero primer lloc es guarda els elements de la primera fila o columna, en segon lloc els elements de de la segona fila o columna i així succesivament fins al final.

M: array [fi..fs, ci..cs] of T

Càlcul de l'adreça:

Per files: @m[i,j]= adr_base(m)+ [(i-fi)*(cs-ci+1)+(j-ci)]* bytes(T)

Per columnes:

@m[i,j]= adr_base(m)+ [(j-ci)*(fs-fi+1)+(i-fi)]*bytes (T).

TEMA 3: MODE D'ADREÇAMENT

Una instrucció pot actuar sobre ningún o mes operands. Els soperands es poden trobar a:

-En la instrucció propia (un operand inmediat).

-En un registre

-En memòria.

Els operands inmediats i els dels registres es poden accedir molt més ràpid que els operands de memòria els quals han de ser carregats de la memòria. Els operands dels registres estan disponibles a la CPU. Els operands inmediats també es troben en la CPU, perque ells ja son precargats en part de la instrucció.

Una instrucció del 386 pot referenciar-se, explícitament, a un o dos operands. Les instruccions de dos operands com MOV, ADD, XOR, etc, generalment sobreescriuen en un dels dos operands el resultat de l'operació. Les instrucions de dos operands explícits permet les següents operacions:

·Registre a registre

·Registre a memòria

·Memòria al registre

·Inmediat al regiatre

·Inmediat a la memòria.

Mai es podran fer operacions que portin informació de memòria a memòruia directament, sempre s'haurà de passar per algun registre.

OPERANDS INMMEDIATS (MODE INMEDIAT)

Algunes instruccions utilitzen dades de la propia instrucció com un dels operands. Aquest operands s'anomenen operand inmediats. L'operand pot ser de 32, 16 o 8 bits.

MOV EAX, imm ;expressió que sempre serà constant.

OPERNADS DE REGISTRES (MODE REGISTRE)

Els operands es poden localitzar en un dels 32, 16 o 8 bits registres genrals.

El 386 te instruccions per referenciar-se als registres de segment (CD, DS, ES, SS, PS, GS). Aquestes instruccions són utilitzades per aplicacions només si el programador ha escollit un model de memoria segmentat.

MOV EAX, EBX

OPERAND A MEMÒRIA (MODE MEMÒRIA)

Les instruccions que manipula dades de memòria han de especificar el segment que conté l'operand i el desplaçament de l'operand dintre del segment.

Les instruccions de manipulació de dades no necesiten especificar explicitament quin registre de segment s'utilitza. Per tots els accessos amemòria, si el segment no està explícit en la instrucció, el processador escogeix un automàticament un registre de codi acorde a les següents regles:

La referencia a memòria necesita usats

Instruccions Codi (CS)

Pila Stack (SS)

Dades Data (DD), el més corrent

La direeció física d'una dada a memòria s'obté sumant els següents components:

·Un desplaçament dintre del segment: on només poden apareixer constants

·Un registre base (Rb): poden ser tots els registres però extessos (EAX, EBX, ECX, EDX, ESI, EDI pel segment de dades DS i ESP, EBP pel segment de la pila SS.)

·Un registre index (Ri): han de ser els registres extessos excepte el ESP. Aquest registre pot estar multiplicat per un factor que pot tenir els següents valors: 1, 2, 4, 8.

MOV EAX, mem ;mem: reg. Segment: despla[Rb+ Ri*factor]

@e = reg. Seg. + despla + Rb + Ri*factor

MOV EAX, ES: A + N*4 [EBX+ECX*2].

A continuació es descriuen alguns cassos particulars d'accés a memòria:

Sigui : A DD ?

Mode absolut: només utilitza el desplaçament.

MOV EAX, A+4.

Mode reg. Indirecte: s'utilitza només el registre base

MOV EAX, ES:[EBX] ; EAX ! MEM [ES:EBX]

MOV EAX, [EBX] ; EAX ! MEM [DS:EBX].

Mode desplaçament: MOV EAX, A[EBX] ; EAX ! MEM [DS:A+EBX].

Mode indexat: MOV EAX, A[EBX*4] ; EAX ! MEM [DS:A+EBX*4]

Altres cassos: MOV EAX, ES:[EBX+ECX*4]; EAX ! MEM [ES: EBX+ECX*4]

TRADUCCIÓ DE LLENGUATGE ALT NIVEL A LLENGUTAGE ASSAMBLADOR

ACCÉS A ESTRUCTURES

•MAT: array [-3.3, 0..10] of integer MAT [i, j] := 0

•@MAT [i, j]= MAT+[(i-(-3))*(10-0+1)+(j-0)]*4 = MAT+[(i+3)*11+j]*4 = MAT+132+ 44i+4j = MAT+132+(11i+j)*4.

MOV ESI, I

MOV EDI, J

IMUL EDX, ESI, 44; EDX <- 44i

MOV MAT+132[EDX+EDI*4], 0

BUCLES

ii, is: enter for i:=ii to is do instruccions endfor	MOV ECX, ii BUCLE:CMP ECX, is JG FI_BUCLE iteració INC ECX JMP BUCLE FI_BUCLE:	MOV ECX, ii CMP ECX, is JG FI_BUCLE BUCLE: iteració INC ECX CMP ECX, is JLE BUCLE FI_BUCLE:
ii, is: enter for i:=is downto ii do instruccions endfor	MOV ECX, is CMP ECX, ii JL FI BUCLE BUCLE: iteració DEC ECX ; activa els flags JGE BUCLE FI_BUCLE:

TEMA 4: SUBRUTINES

INTRODUCCIÓ

una subrutina és un conjunt d'instruccions en llenguatge màquina que realitza una tasca que pot ser parametritzable. És la traducció de les accions i funcions dels llenguatges d'alt nivell.

Els paràmetres formals (els que apareixen en la declaració de la funció) han de coincidir en nombre amb els paràmetres reals de la crida dela funció,per tant no han de coincidir en nom sino en posició y nombre.

Les variables de dins de la funció només afecten a dins de la funció.

Els avantatges de les subrutines són que la mida del programa decreix i que el programa queda més estructurart i això permet utilitzar llibreries predefinides, del que només cal saber la funció que fa i els paràmetres que s'han d'utilitzar.

En canvi amb subrutines unp rograma s'executa més lentament que un altre sense subrutines i a més s'incremeta i es complica el hardware del processador.

Les subrutines es classifiquen en:

-Uninivell: només s'admet un nivell de crida de subrutines, es a dir, no es permet fer crides de funció dins de qualsevol altre crida.

-Multinivell: es poden fer crides de subrutines disn d'altres crides de subrutines.

-Recursives: són un cas especial de les de multinivell, on es crida a una funció i dins d'aquesta es torna a cridar a la mateixa funció.

GESTIÓ DE SUBRUTINES

PP Subr

2

1

4

3

En la gestió de subrutines n'hi han quatre passes a realitzar:

1º-L'activació: -reserva espai pel resultat.

-Fa el pas de paràmetres.

-Fa la crida (salt incondicional a la primera instrucció de la funció).

2º-Inici: -Fa l'enllaç dinàmic (ens permet accedir als paràmetres i resultats de la funció).

-Reserva espai per les variables locals.

-Salvar l'estat (guarda els registres utilitzats a la pila).

3º-Desactivació: -Restaura l'estat.

-Elimina l'espai per les variables locals.

-Desfa l'enllaç dinàmic.

-Retorna al la posició següent despres de fer la crida.

4º-Finalització: -Elimina els paràmetres.

-Guarda el resultat a la variable que indica el programa principal.

En la crida de funcions la pila ens indica quan s'ha fet aquesta crida i la finalització d'aquesta, ja que guarda les adreces de retorn al programa principal.

El bloc d'activació és tota la informació que es manega en la gestió de les subrutines. Aquest bloc conté el resultat, els paràmetres, les adreces de retorn, les variables locals i l'estat.

GESTIÓ DE SUBRUTINES

Suposem: funció f(p1, p2: ent) retorna enter res:=f(a,b)

var loc1, loc2 : enter

loc := p1+p2 ;

retorna loc1/2

ffucnió

ACTIVACIÓ

-Reservar espai pel resultat: el resultat es pot retornar en la pila o en un registre:

PILA ____! SUB ESP, n ; n= nombre de bytes del resultat

REGISTRE _"! "

-Pas de paràmetres: es pas es pot fer per valor (si no porten la capcelera VAR abans dels paràmetres -dades d'entrada-) o per referència (si porten la paraula VAR -dades d'entrada i sortida o només de sortida-) i es poassen a la pila o a registres.

·Pas per valor i a la pila: s'ha de copiar el paràmetre real a la pila. PUSH B o PUSH A

PUSH A PUSH B

·Pas per valor i als registres: s'ha de copiar el paràmetre real al registre. MOV EAX, A

MOV EBX, B

·Pas per referència a la pila: s'ha de col-locar l'adreça del paràmetre real a la pila.

PUSH DS

PUSH OFFSET B

PUSH DS

PUSH OFFSET A

·Pas per referència i a registres: s'ha de col-locar l'adreça del paràmetre real als registres.

P1 -> ES: EAX MOV AX, DS p2-> FS: EBX MOV AX, DS

MOV ES, AX MOV FS, AX

MOV EAX; OFFSET A MOV EBX, OFFSET B

Per defecte nosaltres sempre posarem el resultat a un registre i els paràmetres a la pila i l'ordre de desempilar serà de dreta a esquerra.

-Fer la crida: primer s'ha de guardar la direcció de retorn a l apila i després es fa un salt incondicional a la primera instrucció de la subrutina. Per fer tot aquest procés tenim la instrucció CALL. Aquesta instrucció crida a una subrutina i quan aquesta s'ha acabat la execució del programa continua en la instrucció que segueix a CALL.

CALL nom_subrutina; crida a una subrutina i guarda la direcció de retorn.

CALL nom_subr "" PUSH CS

PUSH IP

CS:IP

La crida es pot fer directament posant el nom de la subrutina o indirectament posant la direcció de la primera instrucció de la subrutina.

INICI

Al fer l'inici de la subrutina ens surgeix un problema. El problema és que degut a l'existencia de variables temporals el cim de la pila no és constant i per tant el desplaçament per accedir als paràmeteres pot canviar, però per solucionar-lo tenim un registres especific “Frame Pointer” (EBP) que apuntarà sempre a la mateixa posició del bloc d'activació de la pila.

-Enllaç dinàmic :inicialitza el EBP per apuntar a una posició fixa.

PUSH EBP

MOV EBP, ESP

-Reservar espai per les avriables locals.

SUB ESP, m ;decrementa el cim em m (m és el nombrede bytes que ocupen les variables locals).

-Salvar l'estat :guardar a la pila tots els registres que modifiquem (que no estiguin involucrats en pas de paràmetres ni en el resultat).

PUSH EAX ø

PUSH EBX ø PUSHAD ; guarda a la pila el valor de tots els

. ø registres en mida doubleword.

Cos de la subrutina

La definició de la subrutina va precedia del nom d'aquesta subrutina amb la paraula PROC i finalitza amb el nom d'aquesta amb la paraula ENDP. Les subrutines normalment es defineixen, en el bloc de codi però abans de fer l'startup.

-Accés als paràmetres : en mode desplaçamanet a través del registre EBP

despl [EBP] ; accedir a p1 ! MOV EAX, 8[EBP]

-Accés a les variables locals : idem que el anterior.

Despl [EBP] ; accedir a loc1 ! MOV EAX, -8[EBP]

-Accés al resultat : idem que les anteriors.

Despl [EBP] ; retornar valor ! MOV 16[EBP], EAX

DESACTIVACIÓ

-Restaurar els registres : POP ECX ø POPAD ; retorna el valor que

POP EBX ø tenien tots els registres

POP EAX ø abans de la crida a la

subrutina.

-Eliminar variables locals : l'únic que es fa es tornar el valor que tenia EBP abans de la subrutina.

MOV ESP, EBP

-Desfer l'enllaç dinàmic : per desfer-lo es treu la informació a EBP de la pila, per a que tingui la informació que tenia el registre abans de la crida.

POP EBP

-Retornar al programa principal :

RET ;és la instrucció final de la subrutina cridada mitjançant CALL.

Amb RET es desempila la direcció de la següent instrucció o CALL en el programa prinicipal. Ret pot anar acompanyat d'un operand el qual indica el nombre de bytes o paraules de la pila que s'eliminen tras treure la direcció de retorn, netjant la pila de paràmetres de la subrutina.

FINALITZACIÓ

-Eliminar peràmetres : aquesta eliminació baixant el punetr de la pila (ESP) tants bytes com bytes total ocupin els paràmetres.

ADD ESP, n ; n=nº de bytes dels paràmetres a la pila.

-Recollir el rsultat : POP RES.

DECISIONS QUE CONSIDEREM SEMPRE :

-El pas de paràmetres es fa a la pila i de dreta a esquerra.

-El pas del resultat es fa a un registres, concretament al EAX.

-Les variables locals es disposen a la pila i l'ultima definida serà a la direcció més alta i la primera a l'adreça més baixa.

-L'eliminació dels paràmetres es fa en dos passes, es a dir utilitzant ADD ESP, n.

-Els enters sempre estarán definits com paraules o dobles paraules.

-Els booleans, caràcters es disposen per valor.

EXEMPLES

funció f(p1, p2: ent) retorna enter res:=f(a,b)

var loc1, loc2 : enter

loc := p1+p2 ;

retorna loc1/2

ffucnió

	loc1	4
	loc2	4
EBP	EBP	4
	@retorn	4
	A=p1	4
	@ B=p2	4

PUSH DS

PUSH OFFSET B ;paràmetre B per referencia

PUSH A ;paràmetre per valor

CALL F

********

F PROC

enllaç dinamic

PUSH EBP ø

MOV EBP, ESP ø

SUB ESP, 8 ø resrvar espai per les variables locals

PUSH ES ø

PUSH EBX ø salvar l'estat

PUSH ECX ø

MOV EBX, 8[EBP] ø

LES CX, 12[EBP] ø

MOVZX ECX, CX ø loc1 :=p1+p2

ADD EBX, ES :[ECX]ø

MOV -8[EBP], EBX] ø

retorna loc1/2

MOV EAX, -8[EBP] ø

SAR EAX, 1 ø

POP ECX ø

POP EBX ø restaurar l'estat

POP ES ø

MOV ESP, EBP ! eliminar variables locals

desfa l'enllaç dinàmic

POP EBP ø

RET ø

F ENDP

********

ADD ESP, 8

MOV RES, EAX

Llenguatge alt nivell

const N=50

type vector= array [0..N-1] of integer

var v : vector

a, b, c, d : integer

.

.

c := f(v[d], a, v, v[7], b]) ;

function f (var i, j :integer; var vec :vector ;k, l :integer)return integer

var vl :vector

a, d, c :integer

begin

a :=k ;

b :=j ;

c :=vec[i] ;

for a :=0 to N-1 do

vl[a] :=vec[a]

endfor

i :=g (vec, k, a, i, b) ;

a :=g (vl, i, vl[4], l, vl[4])

return vl[a]

endf

.

.

function g (var v :vector, var i, j :integer, k, l :integer)return integer

.

.

Llenguatge ensamblador PILA

	1º accés	2º accés
	@vec= v	@vl= v
	@k= i	@i= i
G1	j= @a	@v[4]= j	G2
	i= k	l= k
	b= l	v[4]= l
	vl[0] VL
	a
	b
	c
EBP	EBP
	@retorn
	@v[d]= i
	@a= j
	@v= vect
	v[t]= t
	b= l

PUSH B

MOV EAX, V+28

PUSH EAX

PUSH DS

PUSH OFFSET V

PUSH DS

PUSH OFFSET A

MOV EAX, D

LEA AX, V[EAX*4]

PUSH DS

PUSH AX

CALL F

ADD ESP, 20

MOV C, EAX

**********
F PROC

PUSH EBP

MOV EBP, SP

SUB ESP, (N+3)*4

PUSH ES,FS

PUSH EBX, ECX, EDX

MOV EBX, 20[EBP]

MOV -12[EBP], EBX

LES BX, 12[EBP]

MOVZX EBX, BX

MOV EBX, ES :[EBX]

MOV -8[EBP], EBX

LES BX, 16[EBP]

MOVZX EBX, BX

LFS CX, 8[EBP]

MOVZX ECX, CX

MOV ECX, FS :[ECX]

MOV ECX, ES :[EBX+ECX*4]

MOV -4[EBP], ECX

MOV -12[EBP], DWORD PTR 0

BUCLE : LES BX, 16[EBP]

MOVZX EBX, BX

MOV ECX, -12[EBP]

MOV EDX, ES :[EBX+ECX*4]

LEA EBX, -(N+3)*4[EBP]

MOV SS :[EBX+ECX*4], EDX

INC -12[EBP]

CMP -12[EBP], N-1

JLE BUCLE

PUSH -8[EBP]

LES BX, 8[EBP]

MOVZX EBX, BX

PUSH ES :[EBX]

LEA BX, -12[EBP]

PUSH SS

PUSH BX

LEA BX, 20[EBP]

PUSH SS

PUSH BX

PUSH 16[EBP]

CALL G

ADD ESP, 20

LES BX, 8[EBP]

MOVZX EBX, BX

MOV ES :[EBX], EAX

PUSH -4*N+4

PUSH 24[EBP

LEA BX, -4*N+4[EBP]

PUSH SS

PUSH BX

PUSH 8[EBP]

LEA BX, -(N+3)*4[EBP]

PUSH SS

PUSH BX

CALL G

ADD ESP, 20

MOV -12[EBP], EAX

MOV EBX, -12[EBP]

MOV EAX, -(N+3)*4[EBP+EBX*4]

POP FS, ES

POP EDX, ECX, EBX

MOV ESP, EBP

POP EBP

RET

F ENDP

TEMA 5 :PERIFÈRICS I CONTROLADORS

INTRODUCCIÓ

La CPU te tres el bus d'adreces que consta de 16 bits, un bus de dades de 8 bits, la senyal address strobe (AS) que es posa a 1 quan la CPU vol accedir a memòria, la senyal de lectura-escriptura (øL/E) que es posa a 1 si es vol escriu i a 0 si es vol llegir de memòria, el senyal READY que indica al processador quan s'ha acabat l'operació de llegir o escriure a la memòria i finalment té el senyal que indica si el porcessador vol accedir a memòria o als perifèrics (øM/P) el qual es posa a 1 si es vol accedir als perifèrics o a 0 si es vol accedir a memòria.

La RAM esta composta pel bus de dades, d'adreces i la senyal de lectura-escriptura, els quals són de la mateixa mida que en la CPU. A més te la senyal ChipSelect (CS) el qual indica el bloc de memòria que s'utilitzarà activant la memòria.