Buffer overflow in a cross-matrix computation in assembly IA-32 x86

  Kiến thức lập trình

My goal is to create a DWORD matrix product of two WORD matrixs. The program produces the right result in all cases I’ve tried, but after printing the result the program crashes because a stack-based buffer overrun was detected.

#include <stdio.h>

void main()
{
    // Number of rows of the first matrix
    unsigned int m = 3;
    // Number of columns of the first matrix
    unsigned int n = 2;
    // Number of columns of the second matrix
    unsigned int k = 4;
    // First matrix
    short int mat1[] = { -1,-2, 4,5, 4,-2 };
    // Second matrix
    short int mat2[] = { 2,0,0,0, 0,2,0,0 };
    // Result matrix
    int mat3[1024];

    __asm {
        // Initialization of the row index to 0
        mov eax, 0          // i = 0

        // Outer loop for the rows of the result matrix
        esterno_ciclo:
        // Check if we have reached the last row of the matrix
        cmp eax, m
            jge fine_ciclo_esterno  // If i >= m, exit the outer loop

            // Initialization of the column index to 0
            mov ebx, 0          // j = 0

            // Inner loop for the columns of the result matrix
            interno_ciclo:
        // Check if we have reached the last column of the matrix
        cmp ebx, k
            jge fine_ciclo_interno  // If j >= k, exit the inner loop

            // Initialization of the sum to 0 for each new cell of the result matrix
            mov dword ptr[ebp - 4], 0  // sum = 0

            // Initialization of the column index of the first matrix to 0
            mov ecx, 0  // l = 0

            // Loop to multiply the elements of the matrices and sum the results
            ciclo_medio:
        // Check if we have reached the last column of the first matrix
        cmp ecx, n
            jge fine_ciclo_medio  // If l >= n, exit the middle loop

            // Calculate the addresses of the current elements of the matrices
            mov edx, eax                      // edx = i
            imul edx, n                       // edx = i * n
            add edx, ecx                      // edx = i * n + l
            movsx esi, word ptr[mat1 + edx * 2]  // esi = mat1[i * n + l]

            mov edx, ecx                      // edx = l
            imul edx, k                       // edx = l * k
            add edx, ebx                      // edx = l * k + j
            movsx edi, word ptr[mat2 + edx * 2]  // edi = mat2[l * k + j]

            // Multiply the elements of the matrices and add to the sum
            imul esi, edi                     // esi = mat1[i * n + l] * mat2[l * k + j]
            add dword ptr[ebp - 4], esi     // sum += mat1[i * n + l] * mat2[l * k + j]

            // Increment l
            inc ecx
            jmp ciclo_medio

            fine_ciclo_medio :

        // Save the sum in the result matrix
        mov edx, eax                   // edx = i
            imul edx, k                    // edx = i * k
            add edx, ebx                   // edx = i * k + j
            mov esi, dword ptr[ebp - 4]  // esi = sum
            mov dword ptr[mat3 + edx * 4], esi  // mat3[i * k + j] = sum

            // Increment j
            inc ebx
            jmp interno_ciclo

            fine_ciclo_interno :

        // Increment i
        inc eax
            jmp esterno_ciclo

            fine_ciclo_esterno :
    }

    // Print to screen
    {   unsigned int i, j, h;
    printf("Product matrix:n");
    for (i = h = 0; i < m; i++)
    {
        for (j = 0; j < k; j++, h++)
            printf("%6d ", mat3[h]);
        printf("n");
    }
    }
}

I can’t understand what the problem is, I’m trying to simplify the program to try not to let it overflow, any advice?

LEAVE A COMMENT