Elaborati Esame - Assembly - Architetture Degli Elaboratori - prof. Maltoni Davide

Elaborato 1

Descrizione: Dato un array di puntatori a stringa (ogni cella del vettore contiene

l'indirizzo a 32 bit del primo carattere della stringa), ordinarlo

alfabeticamente. Ogni stringa termina con il carattere nullo codice ASCII

0).

Esempi di casi importanti da verificare:

∼ Array con una sola stringa

∼ Array con stringhe già in ordine

∼ Array con stringhe ordinate in senso inverso

Attenzione: non è possibile (né conveniente) scambiare il contenuto delle stringhe. Si

devono semplicemente scambiare fra loro gli elementi dell’array (ossia i

puntatori al primo carattere di ciascuna stringa)

********************************************************************************/

/*Il codice seguente è stato testato ed è funzionante su Microsoft Visual Studio*/

#include <stdio.h>

void main() {

// Le stringhe da ordinare (array di puntatori)

char *strings[] = {"retert","gegergr","gegegg","rerter","erwreter","reeerer"};

// Il numero di stringhe nell'array

int num = sizeof(strings)/sizeof(strings[0]);

__asm {

Ciclo2: MOV ECX, num

XOR EBX,EBX

Ciclo : CMP ECX,1

JBE Fine

MOV ESI, strings[ECX * 4 - 4]

MOV EDI, strings[ECX * 4 - 8]

MOV AL, [ESI]

MOV AH, [EDI]

XOR EDX, EDX

LettereInterne: CMP AL, AH

JB Scambio

JNE Next

CMP AL,0

JE Next

INC EDX

MOV AL, [ESI+EDX]

MOV AH, [EDI+EDX]

JMP LettereInterne

Next: LOOP Ciclo

Scambio : INC BL

MOV strings[ECX * 4 - 4], EDI

MOV strings[ECX * 4 - 8], ESI

LOOP Ciclo

Fine: CMP BL,0

JNE Ciclo2

}

// Stampa su video

{ int i;

for (i=0;i<num;i++)

printf("%s\n",strings[i]);

system("pause");

return 0;

}

}

/********************************************************************************

* *

* Architetture dei sistemi di Elaborazione *

* *

********************************************************************************

Elaborato 2

Descrizione:Dato un intero a 32 bit (inteso con segno), costruirne la rappresentazione

floating point (IEEE 754 a singola precisione), restituendo la

rappresentazione binaria (come stringa C di 32 caratteri più carattere

nullo finale) ed esadecimale (come stringa C di 8 caratteri più il

carattere nullo finale).

Si supponga che il numero sia sempre rappresentabile senza errori di arrotondamento.

Esempi di casi importanti da verificare (si riporta solo il risultato in base 16):

∼ Num=0 Risultato atteso: “00000000”

∼ Num=23 Risultato atteso: “41B80000”

∼ Num=-109 Risultato atteso: “C2DA0000”

∼

Attenzione: l’ultimo byte delle stringhe DEVE essere il carattere nullo (codice ascii

zero).

********************************************************************************/

/*Il codice seguente è stato testato ed è funzionante su Microsoft Visual Studio*/

#include <stdio.h>

#include <stdlib.h>

void main() {

// Variabili

int Num=-9299999; // il numero (32 bit in complemento a 2)

char RisultatoBin[33]; // da riempire con la rap. binaria del num.

floating point

char RisultatoHex[9]; // da riempire con la rap. esadecimale del num.

floating point

// Blocco assembler

__asm { MOV EAX, Num

MOV RisultatoBin[0],48

CMP EAX,0

JNL Continua

NEG EAX

MOV RisultatoBin[0],49

Continua: XOR EDX,EDX

CMP EAX,0

JE Ciclo4

MOV ECX,31

Ciclo: MOV EBX,EAX

SHR EBX,CL

AND EBX,1

CMP EBX,0

JNE Stop

DEC ECX

CMP ECX,-1

JNE Ciclo

Stop: LEA EDX,[ECX+127]

MOV ECX,8

Ciclo2: TEST EDX,1

JZ Zero

MOV RisultatoBin[ECX],49

JMP Salta

Zero : MOV RisultatoBin[ECX],48

Salta: ROR EDX,1

CMP ECX,1

LOOPNZ Ciclo2

ROL EDX,8

CMP EAX,1

JNE Avanti

MOV EDX,8

JMP Ciclo4

Avanti: LEA ECX, [EDX-119]

MOV EDX,ECX

Ciclo3: TEST EAX,1

JE Zero1

MOV RisultatoBin[ECX], 49

JMP Salta1

Zero1 : MOV RisultatoBin[ECX], 48

Salta1 : ROR EAX,1

CMP ECX,9

LOOPNZ Ciclo3

Ciclo4: CMP EDX,31

JE FineBin

INC EDX

MOV RisultatoBin[EDX],48

JMP Ciclo4

FineBin: MOV RisultatoBin[32],0

XOR ECX,ECX

XOR EAX,EAX

Ciclo5 : SHL EAX, 1

MOV BL, RisultatoBin[ECX]

CMP BL,48

JE Salta2

INC EAX

Salta2: INC ECX

CMP ECX,32

JNE Ciclo5

XOR EDX,EDX

MOV ECX,28

Ciclo6: MOV EBX,EAX

SHR EBX,CL

AND EBX,15

CMP EBX,9

JBE Numeri

JMP Lettere

Numeri : ADD EBX,48

JMP Salta3

Lettere: ADD EBX,55

Salta3: MOV RisultatoHex[EDX], BL

INC EDX

SUB ECX,4

CMP ECX,-4

JNE Ciclo6

MOV RisultatoHex[8],0

}

// Stampa su video (i due numeri stampati come stringhe devono essere identici)

{

char CheckRisultatoBin[33];

float fNum = (float)Num;

itoa(*(int*)&fNum,CheckRisultatoBin,2);

printf("La rappresentazione binaria del numero %d (floating point) e': \n%s\n

%032s\n",Num,RisultatoBin,CheckRisultatoBin);

printf("\nLa rappresentazione esadecimale del numero %d (floating point) e': \n

%s\n%08X\n",Num,RisultatoHex,*(int*)&fNum);

system("pause");

}

}