Argument of type uint64_t is incompatible with parameter of type void*

Question

I have a function foo(void* pBuf). I need to pass it a 64 bit address but I can't seem to get the right typecast when I'm passing by value.

Example: foo(address). Where- uint64_t address=0x00000000DEADBEEF

EDIT: Compiling using an ARM compiler.

uint64_t foo(void *pBuf){
    uint64_t retAddr = (uint64_t) pBuf;
    retAddr += 0x100000;
    return retAddr;
}

I'm on a 32-bit ARM and sizeof(void *) is 4

Clarification: Why I needed a 64-bit address on a 32-bit ARM? Because my memory map uses 36-bit addressing.

Answer 1

Call it this way:

uint64_t address = 0xDEADBEEF;
foo((void*)address);

That is, you cast the address to a void-pointer to be compatible with the function signature.

Answer 2

You should not use a 64-bits type for an address, as it is undefined behavior for 32-bits (or any non-64 bits) systems.

Rather, prefer using uintptr_t , which is standard C. See this question for more details or this page for references.

Then a solution could be :

uintptr_t address = 0xDEADBEEF;   /* will trigger a warning if the constant is > max possible memory size */
foo((void*)address);

Note : if uintptr_t is not available on your system, size_t is usually a good second choice.

Part 2 :

Looks like, in your rephrased question, you want to convert an address into a 64-bits integer.

In which case, a direct cast from ptr to integer is likely to trigger a compiler warning, due to potential differences in wideness.

Prefer a double cast : uint64_t value = (uint64_t)(size_t) ptr;

Answer 3

I can think of two ways to get this right. Got a solution to my problem by calling foo the first way

1. foo((void*)(uint32_t)address)

This works only because my input to foo is always a 32-bit value. The returned value can be 64-bit.

2. Of course, a proper fix would be to change foo itself, if I could modify it. I could just pass foo(&address). Inside foo, retAddr = *pBuf.

Thanks for all the suggestions!

Answer 4

Sorry to necro this question, but none of these answers seem reasonable to me. This is a fairly straightforward type conversion problem. It seems as though people were caught up on 64-bit addressing on a 32-bit system, when this could easily be for a peripheral or some other address space besides the system itself.

In the OP's case, a cast directly to uint64_t would cause undefined behavior because of the additional four bytes that do not exist in void * . In the case of the M4 calling convention, p would typically be passed in a single register, likely r0 . There are no additional upper bytes for uint64_t to alias, so your compiler is rightly issuing a warning for this.

Under the GCC 7.3 arm-none-eabi port, void * can be safely cast to size_t (aka unsigned int ) because they both have size and alignment of 4 . Once that is done, you can safely promote unsigned int to uint64_t (aka unsigned long long int ) by assignment. The promotion is better defined behavior than a cast.

uint64_t foo(void *p){
    uint64_t a = (size_t) p;
    a += 0x100000;
    return a;
}