NASM malloc returns NULL - malloc

Question

In my attempts to learn NASM, I have tried to create a basic program to test malloc functionality. I have pasted it below:
bits 64
extern malloc
section .data
ARRAY_SIZE: equ 27
array: dq 1
error_message: db "Malloc returned NULL!", 10
error_message_length: equ $ - error_message
section .text
global _start
_start:
; try to allocate an array of bytes in the heap memory using malloc
push dword ARRAY_SIZE
call malloc
;; if malloc returned NULL, throw an error
cmp rax, 0
je err_out
mov [array], eax ; save a pointer to the allocated memory in array
; fill the array with numbers equal to the indices at that location
fill_for:
xor edx, edx ; use edx for the for loop index
.for_start:
cmp edx, ARRAY_SIZE ; break if edx >= BUFFER_SIZE
jg .for_end
mov [array + edx], edx ; array[i] = i;
inc edx
.for_end:
; print the numbers in array
print_for:
xor edx, edx ; use edx for the for loop index
.for_start:
cmp edx, ARRAY_SIZE ; break if edx >= BUFFER_SIZE
jg .for_end
mov eax, [array + edx] ; print array[i]
call print_small_number
.for_end:
print_small_number:
; allocate stack space for the two-digit number string (two digit chars + '\0' = 3b)
;; save the old rbp
mov [rbp], rsp
sub rsp, 8
mov rbp, rsp
;; allocate space for the number string
sub rsp, 3
;; save rdx for the main function
sub rsp, 8
mov [rbp + 3], rdx
; turn the (assumed two-digit in base 10) number into a string in number_string
;; initialize the number to 0x30, 0x30, 0 (0x30 is the offset to turn a number into a base-10 digit; 10 = '\n')
mov byte [rbp], 0x30
mov byte [rbp + 1], 0x30
mov byte [rbp + 2], 10
; the number to print is already in eax
mov bl, 10 ; divide the message length string by 10 to separate the 10s and 1s digits
div bl ;; the quotient is the 10s digits and the remainder is the 1s
add [rbp], al ; move the resulting char into the first slot in number_string
add [rbp + 1], ah ; move the resulting 1s digit char into the second slot in number_string
; print the message length string
mov eax, 4
mov ebx, 1
mov rcx, rbp ; the string starts at rbp
mov edx, 3 ; two digits + \0 = 3 chars = 3b
int 0x80
; return
;; restore the old rdx for the main function
mov rdx, [rbp + 3]
add rsp, 8
;; deallocate the number string
add rsp, 3
;; restore the old rbp
add rsp, 8
mov rbp, [rsp]
ret
err_out:
; print error_message
mov eax, 4
mov ebx, 1
mov ecx, error_message
mov edx, error_message_length
int 0x80
; end the program
mov ebx, 0
mov eax, 1
int 0x80
However, when I call malloc from this basic NASM program, it's returning NULL (0), shown by printing out the following message:
Malloc returned NULL!
I am running this on a laptop with 6GB of RAM with few other applications open and I am only attempting to allocate 27 bytes, so running out of memory seems ridiculously unlikely.
I know that it may return NULL if the size parameter given is negative, but this is not the case as you can see in the code.
Does anyone have any advice? I don't understand why this malloc call could return NULL.
EDIT:
This example was assembled and run in 64-bit Linux Mint 17 Qiana using the following commands since a BASH script:
nasm -f elf64 "$1.asm" -l "$1.lst" &&
ld -s -o "$1" "$1.o" -lc &&
./"$1"

Answer 1

The argument to malloc() should go into rdi, rather than be pushed onto the stack. It's probably failing because you're passing it 0, or some extremely high number.
Also:
mov [array], eax
should be:
mov array, rax
since malloc() is quite capable of returning an address that won't fit into four bytes, and since array doesn't contain a valid memory address at that point, so you shouldn't indirect through it.