Additions:
== Esercizio 20: fix ==
Tradurre in IA32 la funzione C fix:
int media(int,int);
void fix(const int* u, int* v, int n) {
for (i=0; i
int m = media(u[i],u[i+1]);
if (m > media(v[i],v[i+1])) v[i]=m;
Main di prova:
%%(C)
void fix(int* u, const int* v, int n);
int a[] = { 10, 20, 30, 40 };
int b[] = { 0, 25, 28, 30 };
fix(a,b,4);
printf("%d|%d|%d|%d (corretto=15|25|35|30)\n",
b[0], b[1], b[2], b[3]);
##media.s##
%%(C)
.globl media
media:
movl 8(%esp), %eax
addl 4(%esp), %eax
xorl %ecx, %ecx
movl %eax, %edx
shrl $31, %edx
addl %edx, %eax
sarl %eax
Additions:
==Esercizio 19: ordinamento di un array==
Tradurre in IA32 le seguenti tre funzioni C che, combinate, realizzano un semplice algoritmo di ordinamento ([[https://it.wikipedia.org/wiki/Bubble_sort bubblesort]]). Scrivere la soluzione nel file ##es3.s##.
%%(c;es3.c)
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
int makepass(int* v, int n) {
int cont = 0;
while (--n>0)
if (v[n-1]>v[n]) {
swap(v+n-1, v+n);
cont = 1;
}
return cont;
void bubblesort(int* v, int n) {
while (makepass(v,n));
Scrivere tutte le funzioni assembly nello stesso file ##es3.s##:
%%(c;es3.s)
.globl swap
.globl makepass
.globl bubblesort
swap:
ret
makepass:
ret
bubblesort:
ret
Sviluppare il programma incrementalmente, testando le funzioni una alla volta con i seguenti tre main.
Main di prova per la funzione ##swap##:
%%(c;es3-main1.c)
void swap(int* x, int* y);
int a = 10, b = 20;
swap(&a, &b);
printf("a=%d, b=%d\n", a, b); // deve stampare: a=20, b=10
Main di prova per la funzione ##makepass##:
%%(c;es3-main2.c)
int makepass(int* v, int n);
void print(int* v, int n) {
int i;
for (i=0; i
printf("\n");
int v[] = { 2, 3, 4, 5, 1 };
int n = sizeof(v)/sizeof(int);
print(v, n);
makepass(v, n);
print(v, n); // deve stampare 1 2 3 4 5
Main di prova per la funzione ##bubblesort##:
%%(c;es3-main3.c)
void bubblesort(int* v, int n);
void print(int* v, int n) {
int i;
for (i=0; i
printf("\n");
int v[] = { 9, 1, 3, 2, 5 };
int n = sizeof(v)/sizeof(int);
print(v, n);
bubblesort(v, n);
print(v, n); // deve stampare 1 2 3 5 9
Additions:
==Esercizio 18: ricerca in un array==
Deletions:
==Esercizio 18: array==
Additions:
==Esercizio 18: array==
Tradurre in IA32 la seguente funzione C che realizza l'algoritmo di [[https://it.wikipedia.org/wiki/Ricerca_dicotomica ricerca binaria]] su array ordinati. Scrivere la soluzione nel file ##es1.s##.
%%(c;es1.c)
int binsearch(int* v, int n, int x) {
int m = 0; // restituisce 1 <=> x è nell'array ordinato v di dimensione n
while (m
int k = (m+n) >> 1; // indice dell'elemento a meta' fra m ed n
if (x == v[k]) return 1; // x e' in posizione k => trovato
if (x > v[k]) m = k+1; // x puo' essere a destra fra k+1 ed n
else n = k; // x puo' essere a sinistra fra m e k
%%(c;es1-main.c)
int binsearch(int* v, int n, int x);
int res, v[] = { 1, 3, 4, 9, 12 }, n = sizeof(v)/sizeof(int);
res = binsearch(v, n, 0);
printf("%d (corretto: 0)\n", res);
res = binsearch(v, n, 3);
printf("%d (corretto: 1)\n", res);
res = binsearch(v, n, 5);
printf("%d (corretto: 0)\n", res);
res = binsearch(v, n, 12);
printf("%d (corretto: 1)\n", res);
res = binsearch(v, n, 13);
printf("%d (corretto: 0)\n", res);
res = binsearch(v, 1, 1);
printf("%d (corretto: 1)\n", res);
res = binsearch(v, 0, 1);
printf("%d (corretto: 0)\n", res);
Additions:
free(v);
Additions:
short swap(short* p, short* q);
Additions:
==Esercizio 17: variabili locali==
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##get.s##:
%%(c;get.c)
short get(short x, short y) {
short a = x + y;
short b = x - y;
if (a
return b - a;
dove ##swap## è definita come segue (usarla così com'è, senza tradurla in IA32):
%%(c;swap.c)
short swap(short* p, short* q) {
short tmp = *p;
*p = *q;
*q = tmp;
Scrivere un main di prova per testare la correttezza del codice scritto.
Additions:
==Esercizio 16: espressioni booleane==
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##between.s##:
%%(c;between.c)
void between(short x, short y, short z, int* res) {
if (x <= y && y <= z) *res = 1;
else *res = 0;
Additions:
==Esercizio 1: assegnamento e calcolo di espressioni==
==Esercizio 2: accesso a parametri interi di una funzione==
==Esercizio 3: operatori bit a bit==
==Esercizio 4: parametri con meno di 32 bit==
==Esercizio 5: Costrutto if..else: differenza in valore assoluto==
==Esercizio 6: accesso a parametri puntatore di una funzione==
==Esercizio 7: costrutto if...else, puntatori==
==Esercizio 8: array con indice costante==
==Esercizio 9: costrutto while: azzeramento di un array==
==Esercizio 10: costrutto while: azzeramento di un array - variante==
==Esercizio 11: calcolo lunghezza di una stringa==
==Esercizio 12: costrutto ##for##==
==Esercizio 13: somma di matrice==
==Esercizio 14: frequenza caratteri==
==Esercizio 15: rotazione stringhe==
Deletions:
==Esercizio 1 (Assegnamento e calcolo di espressioni)==
==Esercizio 2 (Accesso a parametri interi di una funzione)==
==Esercizio 3 (Operatori bit a bit)==
==Esercizio 4 (Parametri con meno di 32 bit)==
==Esercizio 5 (Costrutto if..else: differenza in valore assoluto)==
==Esercizio 6 (Accesso a parametri puntatore di una funzione)==
==Esercizio 7 (Costrutto if...else, puntatori)==
==Esercizio 8 (Array con indice costante)==
==Esercizio 9 (Costrutto while: azzeramento di un array)==
==Esercizio 10 (Costrutto while: azzeramento di un array - variante)==
==Esercizio 11 (Calcolo lunghezza di una stringa)==
==Esercizio 12 (Costrutto ##for##)==
==Esercizio 13 (Somma di matrice)==
==Esercizio 14 (Frequenza caratteri)==
==Esercizio 15 (Rotazione stringhe)==
Additions:
[ [[EsercAsm1617 A.A. 2016-17]] ]
Deletions:
[[[EsercAsm1617 Versione 2016-17]]]
Additions:
==Esercizio 5 (Costrutto if..else: differenza in valore assoluto)==
Si traduca in Assembly IA32 la seguente funzione C che calcola il valore assoluto della differenza dei parametri, scrivendo un modulo ##mod.s##:
int mod(int x, int y) {
if (x>=y) return x-y;
else return y-x;
Si suggerisce di riscrivere dapprima il programma in una forma C equivalente in cui l'##if (...) istruzione## viene rimpiazzato da un ##if (...) goto##. Scrivere un programma di prova per testare la funzione IA32.
==Esercizio 6 (Accesso a parametri puntatore di una funzione)==
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##raddoppia.s##:
void raddoppia(int* p) {
*p = *p * 2;
Si tenga presente che l'istruzione ##imul## deve avere come operando destinazione necessariamente un registro. Usare il seguente programma di prova:
%%(c;raddoppia_main.c)
void raddoppia(int* p);
int x = 15;
raddoppia(&x);
printf("x=%d\n", x); // deve stampare 30
==Esercizio 7 (Costrutto if...else, puntatori)==
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##cap.s##:
void cap(short* x, short* y) {
if (*x>*y) *x = *y;
Si suggerisce di riscrivere dapprima il programma in una forma C equivalente in cui l'##if (...) istruzione## viene rimpiazzato da un ##if (...) goto##. Scrivere un programma di prova per testare la funzione IA32.
==Esercizio 8 (Array con indice costante)==
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##get_second.s##:
short get_second(short* v, int n) { // v è un array, n è la lunghezza dell'array
short a = -1;
if (n>=2) a=v[1];
return a;
Si suggerisce di riscrivere dapprima il programma in una forma C equivalente in cui l'##if (...) istruzione## viene rimpiazzato da un ##if (...) goto##. Scrivere un programma di prova per testare la funzione IA32.
==Esercizio 9 (Costrutto while: azzeramento di un array)==
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##clear.s##:
void clear(char* v, unsigned n) { // v è un array, n è la lunghezza dell'array
unsigned i=0;
while (i
Si suggerisce di riscrivere dapprima il programma in una forma C equivalente in cui il ##while## viene rimpiazzato da un ##if (...) goto##. Scrivere un programma di prova per testare la funzione IA32.
==Esercizio 10 (Costrutto while: azzeramento di un array - variante)==
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##clear2.s##:
void clear2(char* v, unsigned n) { // v è un array, n è la lunghezza dell'array
char* p=v+n;
while (v
Si suggerisce di riscrivere dapprima il programma in una forma C equivalente in cui il ##while## viene rimpiazzato da un ##if (...) goto##. Scrivere un programma di prova per testare la funzione IA32.
==Esercizio 11 (Calcolo lunghezza di una stringa)==
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##mystrlen.s##:
unsigned mystrlen(const char* s) { // s è una stringa terminata da un terminatore a zero
unsigned n = 0;
while (*s++) n++;
return n;
Si suggerisce di riscrivere dapprima il programma in una forma C equivalente in cui il ##while## viene rimpiazzato da un ##if (...) goto##. Scrivere un programma di prova per testare la funzione IA32.
==Esercizio 12 (Costrutto ##for##)==
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##sum.s##:
short sum(short* v, unsigned n) {
unsigned i;
short s = 0;
for (i=0; i
return s;
Si ricordi che il valore di ritorno di una funzione è sempre a 32 bit per gli interi (##char## e ##short## vengono quindi promossi a ##int##) e viene passato in ##eax##. Si suggerisce di riscrivere dapprima il programma in una forma C equivalente in cui il ##for## viene rimpiazzato da un ##while##, e poi il ##while## da un ##if (...) goto##. Scrivere un programma di prova per testare la funzione IA32.
==Esercizio 13 (Somma di matrice)==
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##matsum.s##:
%%(c;matsum.c)
int matsum(int** v, int n) {
int i, j, s = 0;
for (i=0; i
for (j=0; j
s += v[i][j];
return s;
Si suggerisce di riscrivere dapprima il programma in una forma C equivalente in cui il ##for## viene rimpiazzato da un ##while##, e poi il ##while## da un ##if (...) goto##. Usare il seguente programma di prova:
%%(c;matsum-main.c)
#include
#define N 10
int matsum(int** v, int n);
int i, j, **v = malloc(N*sizeof(int*));
for (i=0; i
v[i] = malloc(N*sizeof(int));
for (j=0; j
}
int s = matsum(v, N);
printf("somma=%d (corretto: 200)\n", s);
for (i=0; i
==Esercizio 14 (Frequenza caratteri)==
Scrivere una funzione C ##void charfreq(const char* text, unsigned* freq)## che calcola per ogni carattere ASCII il suo numero di occorrenze nella stringa ##text##. Il risultato va scritto nell'array ##freq##, che si assume abbia 256 celle. Tradurre poi la funzione scritta in assembly IA32, scrivendo un modulo ##charfreq.s##. Si usi il seguente programma di prova:
%%(c;charfreq-main.c)
#include
void charfreq(const char* text, unsigned* freq);
unsigned i, freq[256];
memset(freq, 0xAF, 256*sizeof(unsigned)); // inizializzazione farlocca per verificare poi se freq viene calcolato correttamente...
charfreq("Traveling through hyperspace ain't like dusting crops, farm boy.", freq);
for (i=0; i<256; ++i) printf(i < 32 || i>127 ? "%3d: %u\n": "\'%c\': %u\n", i, freq[i]); // fra gli altri, deve stampare 'e': 4, ecc.
==Esercizio 15 (Rotazione stringhe)==
Scrivere una funzione C ##void rotstr(char* s, int i)## che, dato un intero ##i## in ##[0,n-1]##, dove ##n## è lunghezza della stringa, ruota la stringa verso destra di ##i## posizioni. Ad esempio, se ##s="roma"##, la stringa è modificata come segue:
~- ##rotstr(s, 0)## -> ##s="roma"##
~- ##rotstr(s, 1)## -> ##s="arom"##
~- ##rotstr(s, 2)## -> ##s="maro"##
~- ##rotstr(s, 3)## -> ##s="omar"##
La trasformazione deve avvenire in-loco, cioè modificando l'array ##s## stesso senza usare alcun buffer di appoggio. Tradurre poi la funzione scritta in assembly IA32, scrivendo un modulo ##rotstr.s##.
Additions:
%%(c;diff.c)
char diff(char x, char y) {
return x - y;
Deletions:
##
Additions:
==Esercizio 4 (Parametri con meno di 32 bit)==
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##diff.s##:
%%(c;main.c)
char diff(char x, char y);
char z = diff(10, 20);
printf("%hd\n", z); // deve stampare -10
##
Additions:
~&**Suggerimento:** usare le istruzioni IA32 NOT e AND.
Deletions:
//Suggerimento//: usare le istruzioni IA32 NOT e AND.
Additions:
//Suggerimento//: usare le istruzioni IA32 NOT e AND.
Additions:
short expr() {
Scrivere un file ##expr.s## che contiene la traduzione IA32 della funzione C ##expr##. Compilare il programma insieme al main di prova, ricordando che il valore restituito da una funzione per convenzione è contenuto nel registro A:
%%(c;expr_main.c)
short expr(); // prototipo per la funzione definita nel modulo es1.s
short z = expr();
printf("expr() -> %hd\n", z); // stampa contenuto variabile z
Per compilare il programma, usare ##gcc -m32 expr_main.c expr.s -o expr##, che genera un eseguibile ##expr##.
Deletions:
short es1() {
Scrivere un file ##es1.s## che contiene la traduzione IA32 della funzione C ##es1##. Compilare il programma insieme al main di prova, ricordando che il valore restituito da una funzione per convenzione è contenuto nel registro A:
%%(c;es1_main.c)
short es1(); // prototipo per la funzione definita nel modulo es1.s
short z = es2();
printf("es2() -> %hd\n", z); // stampa contenuto variabile z
Per compilare il programma, usare ##gcc -m32 es2_main.c es2.s -o es2##, che genera un eseguibile ##es2##.
Additions:
Si traduca in Assembly IA32 la seguente funzione C, scrivendo un modulo ##pari.s##:
Additions:
printf("pari(81)=%d\n", pari(81)); // deve stampare 0
Deletions:
printf("pari(81)=%d\n", pari(81)); // deve stampare 0