从 C 程序调用 x86 汇编函数时检索到的矩阵值不正确

Question

I am writing a C program that adds the values of two cells in two matrices. In my C program, I call an Assembly function that implements the function to add the two cells. That function has the following signature:

// Adds two matrix cells together and returns the result
int addTwoCells(int **matrixA, int aRows, int aColumns, int cellARow, int cellAColumn,
        int **matrixB, int bRows, int bColumns, int cellBRow, int cellBColumn);

Below is my C program ( main.c ): I am defining 2 dynamically allocated 3x3 matrices, with the bottom right corner of each matrix set to 3. I am intenting to add the bottom right corners through the function call:

#include <stdio.h>
#include <stdlib.h>

// Adds two matrix cells together and returns the result
int addTwoCells(int **matrixA, int aRows, int aColumns, int cellARow, int cellAColumn,
        int **matrixB, int bRows, int bColumns, int cellBRow, int cellBColumn);

int main(void) {
    // Define the dimensions for matrix A
    int rA = 3;
    int cA = 3;

    // Define the double pointer that defines matrix A
    int **matrixA;
    // Dynamically allocate space for the entire matrix
    matrixA = (int**) malloc(rA * sizeof(int*));
    // Dynamically allocate sufficient space for each row in the entire matrix
    for (int i = 0; i < rA; i++) {
        matrixA[i] = (int*) malloc(cA * sizeof(int));
    }

    matrixA[2][2] = 3;

    // Define the dimensions for matrix B
    int rB = 3;
    int cB = 3;

    // Define the double pointer that defines matrix B
    int **matrixB;
    // Dynamically allocate space for the entire matrix
    matrixB = (int**) malloc(rB * sizeof(int*));
    // Dynamically allocate sufficient space for each row in the entire matrix
    for (int i = 0; i < rB; i++) {
        matrixB[i] = (int*) malloc(cB * sizeof(int));
    }

    matrixB[2][2] = 3;

    // Test calling the matrix multiplication function using the static library
    // compiled from the Assembly file
    printf("%d\n", addTwoCells(matrixA, rA, cA, 2, 2, matrixB, rB, cB, 2, 2));

    return EXIT_SUCCESS;
}

Below is my x86 Assembly program ( addTwoCells.s ). I first process in all the parameters and then I try to retrieve the value of the cell at the bottom right corner of the first matrix. To do this, I first compute the flattened index corresponding to the bottom right corner (which after debugging is correct: 2*(column count) + 2 = 2*3 + 2 = 8 ). However, when I try to retrieve the integer at that flattened index + the memory address of the first matrix ( matrixAStartingAddress ), the result is always a crazy large number (like 1478295976) when it should be 3 , as shown in the output of the function (stored in the EAX register). This seems strange, since it seems that I am processing the parameters correctly and am moving the value at the memory address %ecx through the expression (%ecx) , not the memory address itself:

# Function signature:
# int addTwoMatrixCells(int **matrixA, int aRows, int aColumns, int cellARow, int cellAColumn,
# int **matrixB, int bRows, int BColumns, int cellBRow, int cellBColumn)

.data
    # Matrix A dimensions
    aRows:
        .int 0

    aColumns:
        .int 0

    # Coordinate of cell A
    cellARow:
        .int 0

    cellAColumn:
        .int 0

    # Matrix B dimensions
    bRows:
        .int 0

    bColumns:
        .int 0

    # Coordinate of cell B
    cellBRow:
        .int 0

    cellBColumn:
        .int 0

    # The starting memory address of matrix A
    matrixAStartingAddress:
        .int 0

    # The starting memory address of matrix B
    matrixBStartingAddress:
        .int 0

.text
# Defining a function addTwoMatrixCells
.global addTwoCells
addTwoCells:
    # Prologue
    push %ebp
    movl %esp, %ebp

    # Process in parameter 1: the starting memory address of matrix A
    movl 8(%ebp), %ecx
    movl %ecx, matrixAStartingAddress

    # Process in parameter 2: the number of rows in matrix A
    movl 12(%ebp), %ecx
    movl %ecx, aRows

    # Process in parameter 3: the number of columns in matrix A
    movl 16(%ebp), %ecx
    movl %ecx, aColumns

    # Process in parameter 4: the row index of cellA
    movl 20(%ebp), %ecx
    movl %ecx, cellARow

    # Process in parameter 5: the column index of cellA
    movl 24(%ebp), %ecx
    movl %ecx, cellAColumn

    # Process in parameter 6: the number of rows in matrix B
    movl 28(%ebp), %ecx
    movl %ecx, bRows

    # Process in parameter 7: the number of columns in matrix B
    movl 32(%ebp), %ecx
    movl %ecx, bColumns

    # Process in parameter 8: the row index of cellB
    movl 36(%ebp), %ecx
    movl %ecx, cellBRow

    # Process in parameter 9: the column index of cellB
    movl 40(%ebp), %ecx
    movl %ecx, cellBColumn

    # Compute the flattened index of the cell in matrix A
    # One of the arithmetic operators needs to be in a CUP register
    # In this case, we designate ECX register to store the number of columns
    # in matrix A (n) initially, but ECX after the computation will store
    # the memory address of cellA in the matrix
    movl aColumns, %ecx
    imul cellARow, %ecx
    addl cellAColumn, %ecx
    addl matrixAStartingAddress, %ecx
    movl (%ecx), %eax

    # Compute the flattened index of the cell in matrix B

    # Epilogue
    movl %ebp, %esp
    pop %ebp
    ret

Answer 1

Problem 1: You forgot the starting memory address of matrix B. It should be parameter 6, and what you currently call parameters 6-9 should become 7-10.

Problem 2: int s are 4 bytes wide in x86, but you're calculating the address of the cell as if they're only 1 byte wide.

Problem 3: You're passing a double pointer from C to addTwoCells , but your assembly code treats it like it's a 2D array. These are not compatible types. Try compiling these two C functions and comparing the resulting assembly :

int readValuePtr(int rows, int cols, int cellRow, int cellCol, int **matrix) {
    return matrix[cellRow][cellCol];
}

int readValueArr(int rows, int cols, int cellRow, int cellCol, int matrix[rows][cols]) {
    return matrix[cellRow][cellCol];
}