GDB: Displaying incorrect values in struct

Question

I'm trying to implement the malloc function and it looks like that gdb is giving me some weird values from this struct:

struct MemoryBlock {

    struct MemoryBlock * next;
    size_t               size;
    signed char          is_free;
} startBlock;

And that's the function where I'm debugging it with gdb:

struct MemoryBlock * create_new_block(size_t size)
{

    struct MemoryBlock * ret_block;

    // add some space for the struct block
    size += sizeof(struct MemoryBlock);

    ret_block = (void *) sbrk(size);

    // test first, if we can allocate that much of ram
    if (ret_block == (void *) -1)
        return NULL;

    ret_block->size    = size - sizeof(struct MemoryBlock);
    ret_block->is_free = 0;
    ret_block->next    = NULL;

    return ret_block; // HERE'S the breakpoint
}

So here's the issue (I'm at the breakpoint return ret_block):

If I want to see what kind of values are inside of the ret_block pointer, than I'm getting this:

(gdb) p (struct MemoryBlock) ret_block
$26 = {next = 0x555555559000, size = 140737488347680, is_free = -53 '313'}

size is fine, because if I convert it into the decimal system than I'm getting 3 as expected. (the argument size from the function is currently 3)

But I'm surprised that next and is_free aren't 0 since the last three lines should set both to 0.

So I looked up what is in the memory:

As you can see each value is correctly stored in my heap. But why am I getting these values if I do p (struct MemoryBlock) ret_block?

If you need the whole code

#include <unistd.h>
#include <stdio.h>

/* ============
 * Structs 
 * ============ */
struct MemoryBlock {

    struct MemoryBlock * next;
    size_t               size;
    signed char          is_free;
} startBlock;

/* ==============
 * Functions 
 * ============== */
struct MemoryBlock * create_new_block(size_t size);
void * malloc(size_t size);

/* ==================
 * Main Programm 
 * ================== */
int main()
{

    char * buffer;
    char * b2;
    unsigned short index;

    // The start of my heap :D
    startBlock.is_free = 0;
    startBlock.size    = 0;

    buffer = malloc(3);
    b2 = malloc(3);
    
    // ----- ERROR -----
    if (buffer == NULL || b2 == NULL)
        return 1;
    // ----- ERROR -----
    
    // fill the buffers with random stuff
    for (index=0; index<2; index++) {
        buffer[index] = 'a';
        b2[index] = 'b';
    }

    buffer[index] = '';
    b2[index] = '';
    puts(buffer);
    puts(b2);

    return 0;
}

struct MemoryBlock * create_new_block(size_t size)
{

    struct MemoryBlock * ret_block;

    // add some space for the struct block
    size += sizeof(struct MemoryBlock);

    ret_block = (void *) sbrk(size);

    // test first, if we can allocate that much of ram
    if (ret_block == (void *) -1)
        return NULL;

    ret_block->size    = size - sizeof(struct MemoryBlock);
    ret_block->is_free = 0;
    ret_block->next    = NULL;

    return ret_block;
}

void * malloc (size_t size)
{

    struct MemoryBlock * ret_block;
    struct MemoryBlock * prev_block;

    prev_block = &startBlock;
    ret_block = startBlock.next;

    // go through the linked lists and look if you can find a suitable block
    while (ret_block != NULL && (ret_block->size < size || !ret_block->is_free)) 
    {
        prev_block = ret_block;
        ret_block = ret_block->next;
    }

    // couldn't find a suitable block => create a new one
    if (ret_block == NULL) {
        ret_block = create_new_block(size);

        if (ret_block == NULL)
            return NULL;
    }

    prev_block->next = ret_block;
    ret_block->is_free = 0;
    return ret_block;
}

Answer 1

Ok, one of my friends told me my issue... The casting was wrong! Here's the solution:

(gdb) p * ret_block
$57 = {next = 0x0, size = 3, is_free = 0 '00'}

A star was enough to get the desired output...