using pointer aritmetic in void*

Question

My machine is ubuntu 20.04

I have a assignment that say "Using the system calls (mmap and munmap) implement your own functions for dynamic memory allocation: mymalloc and myfree, which have the same functionality as malloc and free from the standard C library. Save the implementations in files mymalloc.h and mymalloc.c."

And then it says "we must allocate at least the desired length + the size of the variable for storing the length (size_t). We store the length as first element, then return the next element."

It is my code (size is parameter in type size_t)

size_t total_size = size + sizeof(size_t);

size_t allocation_overflow = total_size % page_size;

if(allocation_overflow > 0)
    total_size += page_size - allocation_overflow;

void *data = mmap(NULL ,total_size, PROT_EXEC | PROT_READ | PROT_WRITE , MAP_PRIVATE , 0 , 0);

  // size_ptr will point to stored size
  size_t *size_ptr =(size_t *)data;

  size_ptr[0] = total_size;


  // pointer to allocated memory
  void* allocated_mem_pointer = data + sizeof(size_t);

and it give warning "pointer type 'void*' used in arithmetic [-Wpointer arith]"

ı must store the length in first element because assignment says it but ı don't warnings ı want to write clean code . İS there a legal for it. I already read Pointer arithmetic when void has unknown size but couldnt find any answer to solve it.

You could make `data` a pointer to `char` (`char*`). You are incrementing by a number returned from `sizeof` and `sizeof(char)` is guaranteed to be 1, so you're basically incrementing by a multiple of `sizeof(char)` anyway. — Stefan Riedel, Jan 25 '21 at 09:47

Robert · Answer 1 · 2021-01-25T09:52:04.957

When you use pointers arithmetic (ie add a number to pointer) you need to type your pointer properly:

IntPointer32Bits + 1 => will give the address of the next adjacent 32 bits integer
IntPointer16Bits + 1 => will give the address of the next adjacent 16 bits integer

The resulting address of pointer arithmetic depends on the pointer type.

void* allocated_mem_pointer = data + sizeof(size_t);

In this case, data is a void *, so the pointer arithmetic is not clear for the compiler (need to calculate next 8 bits, next 16 bits or next 32 bits ?). You shouldn't use void * but you should have a real type instead, I assume uint8_t.

size_t total_size = size + sizeof(size_t);

size_t allocation_overflow = total_size % page_size;

if(allocation_overflow > 0)
    total_size += page_size - allocation_overflow;

uint8_t *data = mmap(NULL ,total_size, PROT_EXEC | PROT_READ | PROT_WRITE , MAP_PRIVATE , 0 , 0);

  // size_ptr will point to stored size
  size_t *size_ptr =(size_t *)data;

  size_ptr[0] = total_size;


  // pointer to allocated memory
  uint8_t *allocated_mem_pointer = data + sizeof(size_t);

In this case, your intent is very clear for the compiler: the allocated_mem_pointer is a memory area composed of uint8_t, the computed address is the base address of data with an offset of size_t bytes. (the operator sizeof returns the number of bytes aka uint8_t.)

but if I type cast my void pointer data can ı return that "data" pointer without any problem. Maybe not int first try but is there any problem in multiple calls — Muzaffer, Jan 25 '21 at 09:52
Yes you can also cast it before doing the arithmetic. `void* allocated_mem_pointer = (uint8_t *)data + sizeof(size_t);` Should also work. — Robert, Jan 25 '21 at 09:54

Gerhardh · Accepted Answer · 2021-01-25T10:24:04.863

0

As you found out, you cannot do arithmetics with void* unless you are using GCC extensions or similar.

The simple solution is: Don't use void*.

In your code you already have

  // size_ptr will point to stored size
  size_t *size_ptr =(size_t *)data;
  size_ptr[0] = total_size;

Now you want to calculate the address that comes after your counter header.

The element that comes after arr[0] is simply arr[1].

Use this to get the address for caller:

  // pointer to allocated memory
  void* allocated_mem_pointer = &size_ptr[1];

When you want to get back to that header in your myfree function you can do similar trick:

void myfree(void*addr) {
   size_t *buff = (size_t*) addr;
   size_t header = buff[-1];
   // ... 
}

This is valid because buff[-1] points into the same memory oject that was initially allocated in your myalloc function.

Note:

If you were to create a function that is not only used for educational purposes, you would also need to handle proper alignment for the address you return to the caller.

edited Jan 25 '21 at 10:24

answered Jan 25 '21 at 09:49

Gerhardh

11,688
4
17
39

Could you tell me what are these GCC extensions and thanks for answer – Muzaffer Jan 25 '21 at 09:57
GCC allows doing caculations to `void*`. Just as if it was `char*`. As with all extensions, they are not portable and I would not recommend to use them unless you really need to. Which is obviously never the case for this extension. – Gerhardh Jan 25 '21 at 09:58
I rather suspect that the correct solution in this case is to use some manner of struct pointer where the first item is a `size_t`. Possibly a flexible array member at the end: `typedef struct { size_t size; uint8_t data[]; } heapseg_t;` or similar. – Lundin Jan 25 '21 at 10:05

score 0 · Answer 3 · answered Jan 25 '21 at 09:54

0

When dealing with void*, do arithmetic on char* or unsigned char* pointers.

void *allocated_mem_pointer = (char*)data + sizeof(size_t);

answered Jan 25 '21 at 09:54

KamilCuk

120,984
8
59
111

or `(size_t *)data + 1` – M.M Jan 25 '21 at 09:56
I think it would be good if you explained why – klutt Jan 25 '21 at 10:05

using pointer aritmetic in void*

3 Answers3