Multiplicação de Matriz [C/C++ com Assembly ]

cesarsst
(usa Ubuntu)

Enviado em 24/06/2017 - 12:15h

Estou tentando realizar um programa que realize a multiplicaçao de matrizes (mais especificamente 3 matrizes (B x A x 2C) ) e preciso realizar essa operação tanto em C, quanto em Assembly (2 funções - uma em GAS e outra em NASM). Em C sem problemas, está rodando perfeito, porém quando tento realizar a copilação (usando o gcc) está dando falha de segmentação. Vari o codigo varias vezes e realmente não acho onde pode estar o problema (ou se a logica utilizada está errada). Segue o codigo abaixo:

Detalhe: Para realizar a "coleta" das areas da matriz (como só pode ser representado em vetor em assembly), estou usando a seguinte logica:

X = L x i + j
Onde,
L = ordem da matriz quadrada;
i = linha desejada da matriz e,
j = coluna desejada da matriz.

Como estamos representando uma matriz com números inteiros, multiplicamos o resultado desse cálculo por 4, pois um número inteiro possui 4 bytes. (pode ser observado no codigo em GAS essa logica).

#include <stdio.h>


const int L = 5;

void multMatrixN(int m1[L][L], int m2[L][L], int r[L][L], int L);
void multMatrixG(int m1[L][L], int m2[L][L], int r[L][L], int L);
void multMatrixC(int m1[L][L], int m2[L][L], int r[L][L]);
void printMatrix(int m[L][L]);
void doubleMatrix(int m[L][L]);
int smallestMatrix(int m[L][L]);

void main(void){
	int a[L][L], b[L][L], c[L][L], r[L][L], aux[L][L];
	int i, j;
	
	for(i=0; i<L; i++){				// INICIALIZAÇÃO DAS MATRIZES
	   for(j=0; j<L; j++){
		   a[i][j] = 2*i+1;
		   b[i][j] = 2*j+1;
		   c[i][j] = i*j+1;
		   r[i][j] = 0;
	   }
   }

	doubleMatrix(c);

   multMatrixG(a,b,aux,L);
   //multMatrixN(aux,c,r,L);
   
   
	/*
	printf("\n\n\t   MATRIZ A\n\t");
	printMatrix(a);
	
	printf("\n\t   MATRIZ B\n\t");
	printMatrix(b);
		
	printf("\n\t   MATRIZ 2C\n\t");
	doubleMatrix(c);
	printMatrix(c);
	
	multMatrix(a, b, aux);
	multMatrix(aux, c, r);
	*/
	printf("\n\n\t   MATRIZ RESULTADO\n\t");
	printMatrix(r);
	
	printf("\n\n\tO menor valor da diagonal principal é %d", smallestMatrix(r));
}

//Função que realiza multiplicação em NASM
/*
void multMatrixN(int m1[L][L], int m2[L][L], int r[L][L], int L){

   asm("SECTION .data");
   asm("i:     db 0");
   asm("j:     db 0");
   asm("k:     db 0");
   asm("soma:  db 0");
   
   asm("SECTION .text");
   asm("global start");
   asm("_start:");
   
   asm("    mov edi, [ebp+12]"); //M2
   asm("    mov esi, [ebp+8]");  //M1
   
   asm("    forIloop:"); 
   asm("       forJloop:");
   asm("          mov soma, 0");
   asm("          forKloop:");
   asm("             mov eax, [ebp+20]");     // Calculo do endereco para m1
   asm("             mov ebx, i");
   asm("             mul bl");
   asm("             add eax, k");
   asm("             sal eax, 2");        
   asm("             mov ecx, eax");            // ecx = (L*i + k)*4
    
   asm("             mov eax, [ebp+20]");     // Calculo do endereco para m2
   asm("             mov ebx, k");
   asm("             mul bl");
   asm("             add eax, j");
   asm("             sal eax, 2");        
   asm("             mov edx, eax");            // edx = (L*k + j)*4
   
   asm("             mov eax, [esi+ecx]");          // Calculo da multiplicacao
   asm("             mov ebx, [edi+edx]");
   asm("             mul ebx");
   asm("             add soma, eax");
   
   asm("             inc k");
   
   asm("          forKcond:");
   asm("             cmp k,[ebp+20]");
   asm("             jne forKloop");
   
   asm("             mov eax, [ebp+20]");     // Calculo do endereco para r
   asm("             mov ebx, i");
   asm("             mul bl");
   asm("             add eax, j");
   asm("             sal eax, 2");        
   asm("             mov ecx, eax");            // ecx = (L*i + j)*4
   
   asm("             mov ebx,[ebp+16]");
   asm("             mov [ebx+ecx], soma");
   
   asm("             inc j");
   
   asm("       forJcond:");
   asm("          cmp j, [ebp+20]");
   asm("          jne forJloop");
   
   asm("          inc i");
   asm("    forIcond:");
   asm("       cmp i, [ebp+20]");
   asm("       jne forIloop");
   
}*/

//Função que realiza multiplicação em GAS
void multMatrixG(int m1[L][L], int m2[L][L], int r[L][L], int L){

   asm(".data");
   asm("i:     .byte 0");
   asm("j:     .byte 0");
   asm("k:     .byte 0");
   asm("soma:  .int 0");
   
   asm(".text");
   
   asm("    movl 12(%ebp), %edi"); //M2
   asm("    movl 8(%ebp), %esi");  //M1
   
   asm("    movl 20(%ebp), %eax");
   asm("    movl %eax, i");

   asm("    forIloop:");
   asm("       decl i");
   asm("       movl 20(%ebp), %eax");
   asm("       movl %eax, j");
   asm("       forJloop:");
   asm("          decl j");
   asm("          movl $0, soma");
   asm("          movl 20(%ebp), %eax");
   asm("          movl %eax, k");
   asm("          forKloop:");
   asm("             decl k");
   asm("             movl 20(%ebp), %eax");     // Calculo do endereco para m1
   asm("             movl i, %ebx");
   asm("             mull %ebx");
   asm("             addl k, %eax");
   asm("             sall $2, %eax");        
   asm("             movl %eax, %ecx");            // ecx = (L*i + k)*4
    
   asm("             movl 20(%ebp), %eax");     // Calculo do endereco para m2
   asm("             movl k, %ebx");
   asm("             mull %ebx");
   asm("             addl j, %eax");
   asm("             sall $2, %eax");        
   asm("             movl %eax, %edx");            // edx = (L*k + j)*4
   
   asm("             movl (%esi,%ecx),%eax");          // Calculo da multiplicacao
   asm("             movl (%edi,%edx),%ebx");
   asm("             mull %ebx");
   asm("             addl %eax, soma");
   
   asm("          forKcond:");
   asm("             cmpl $0, k");
   asm("             jne forKloop");
   
   asm("             movl 20(%ebp), %eax");     // Calculo do endereco para r
   asm("             movl i, %ebx");
   asm("             mull %ebx");
   asm("             addl j, %eax");
   asm("             sall $2, %eax ");        
   asm("             movl %eax, %ecx");            // ecx = (L*i + j)*4
   
   asm("             movl $soma, %ebx");
   asm("             movl 16(%ebp), %eax");
   asm("             movl %ebx, (%eax,%ecx)");
   
   asm("       forJcond:");
   asm("          cmpl $0, j");
   asm("          jne forJloop");

   asm("    forIcond:");
   asm("       cmpl $0, i");
   asm("       jne forIloop");
   
}

void multMatrixC(int m1[L][L], int m2[L][L], int r[L][L]){ //REALIZA MULTIPLICAÇÃO DE MATRIZ
	int i, j, k, soma = 0;
	
	for(i=0; i<L; i++){	
	   for(j=0; j<L; j++){
	      r[i][j] = 0;
		
	      for(k=0; k<L; k++){
	         soma += m1[i][k] * m2[k][j];
	      }
	      r[i][j] = soma;
	      soma = 0;
	   }	
	}
}

void printMatrix(int m[L][L]){	// PRINT MATRIZ
	int i, j;
	
	for(i=0; i<L; i++){				
	   for(j=0; j<L; j++){
	      printf("%5d",m[i][j]);
	   }
	   printf("\n\t");
	}
}

void doubleMatrix(int m[L][L]){ // DOBRO DA MATRIZ
	int i, j;
	
	for(i=0; i<L; i++){				
	   for(j=0; j<L; j++){
	      m[i][j] *= 2;
	   }
	}
}

int smallestMatrix(int m[L][L]){ // RETORNA MENOR VALOR DA DIAGONAL PRINCIPAL
	int i, menor = 99999;
	
	for(i=0; i<L; i++){
	   if(m[i][i] < menor)
	      menor = m[i][i];
	}
	
	return menor;
} 

OBS: A função que realiza a multiplicação em NASM está comentada porque ainda tenho que verificar os comandos se estão corretas, porém se alguem puder simplismente verificar a logica em GAS e me dizer se está correta agradeço!