error: invalid type argument of unary ‘*’ (have ‘long int’)

Question

This is a small program written by me to print the value stored at memory location (0x7fffdf222fec).I am getting error as 4:20: error: invalid type argument of unary ‘*’ (have ‘long int’ printf("\n %p ",*(0x7fffdf222fec));

I am using gcc compiler in ubuntu 16.04.My ram is 4 GB. Cannot i access values at this location using this way?

#include<stdio.h>
void main(){
    printf("\n  %p   ",*(0x7ffeae3b3674));
}

The expected result is the junk value stored at the address

I wrote a program like this and got the address of a as

#include<stdio.h>
void main(){
    int a;
    printf("%p",&a);
}

0x7ffeae3b3674

Then i applied the above address to t he first program.

Answer 1

Change *(0x7fffdf222fec) to *(int*)0x7fffdf222fec.

0x7fffdf222fec is a constant with type long int. You cannot dereference non-pointer types, so you need to cast it to a pointer first. Which pointer you choose depends on how you want to interpret the data at that address. I chose int* for this example, but you can choose any pointer type except void*.

Note though that chances are that this will segfault. Don't do this unless you're sure that you have access to that location.

To clarify:

Cannot i access values at this location using this way?

Well, it depends on what you mean. It is the right way to read that specific location. The problem is that you might not have access to it.

The access control is in general out of your reach. A segmentation fault is basically the operating systems way of telling you that you did something naughty.

You can read more about segmentation faults here

Gaining access to an arbitrary part of the memory is pretty complex and also heavily system dependent. It's not done in the same way on a Unix machine as it is on a Windows machine.

Also remember that most modern operating systems utilizes virtual memory, so the address you're trying to read is not the physical address. The OS maps a virtual address to a physical address. Read more here

I wrote a program like this and got the address of a as

You're not guaranteed to get the same address each time you run the program. If you have declared a variable, you obviously have access to it. Try to run the program several times. Chances are high that you will get a different address each time.

Unless you have very specific needs, such as coding drivers, kernels or embedded systems, you should never worry about absolute addresses.

Answer 2

You cannot have a value without having a type.

Quoting from ISO9899, 6.2.5 Types p1,

The meaning of a value stored in an object or returned by a function is determined by thetypeof the expression used to access it.

You try to dereference the address 0x7ffeae3b3674 but you do not tell it what type has the object from that address.

An object is a region of data storage whose contents contain values, but in order to get a value of an object you need to inform it what type the object has, such that the compiler to know how to decode the information from the given object.

At the given address when you know that there is an integer there, you need to inform it to dereference an object of int type, by first casting the address to pointer to integer, such that the * operator to dereference an integer (and also use %d to inform printf that the passed parameter is an object of type int):

printf("\n  %d   ",*((int*)0x7ffeae3b3674))

Other problem that can appear is that after you get the address from the first program you cannot know if after the second compilation the compiler will allocate the variable a the same address or that the memory segment is still valid. You need to check this using readelf.

Answer 3

I was tempted to search for a duplicate question about reading values from a given address.

This would simply require that you convert that plain address value into a pointer.

Something like that:

int *p = (int *)0x1000000;
printf("value=%d", *p);

But your question is a bit different.

Normally a given address is used to access some hardware registers or similar.

Your code has additional problems.

#include<stdio.h>
void main(){
  printf("\n  %p   ",*(0x7ffeae3b3674));
}

First of all, it must be int main(void) as proper prototype for main.

Second: You do not have a pointer type. While you could solve this with a cast as shown above, you also try to print it as a pointer using %p. But when you dereference a pointer you need the type of value where it points to. Probably an int in your case.

Third: The address you are using is useless. You cannot assume that a certain variable is located at a specific address. Your program can use different addresses each time it is loaded. Also the variable that used to be there in first test, it no longer present in your new test. The compiler will not reserve memory at this location. Whatever is stored there, it does not belong to you! Accessing it is UB.