CODEWITHSUNDEEP
c
Laurentiu
Laurentiu

Reputation: 163

How to store a variable at a specific memory location?

As i am relatively new to C , i have to use for one of my projects the following: i must declare some global variables which have to be stored every time the program runs at the same memory address. I did some read and i found that is i declare it "static" it will be stored at the same memory location.

But my question is: can i indicate the program where to store that variable or not. For example : int a to be stored at 0xff520000. Can this thing be done or not? i have searched here but did not found any relevant example. If their is some old post regarding this, please be so kind to share the link .

Thank you all in advance. Laurentiu

Update: I am using a 32uC

Upvotes: 15

Views: 48673

Answers (8)

karim hussen
karim hussen

Reputation: 11

according your compiler if you use XC8 Compiler. Simply you can write int x @ 0x12 ;

in this line you set x in the memory location 0x12

Upvotes: 1

Lundin
Lundin

Reputation: 213711

In your IDE there will be a memory map available through some linker file. It will contain all addresses in the program. Read the MCU manual to see at which addresses there is valid memory for your purpose, then reserve some of that memory for your variable. You have to read the documentation of your specific development platform.

Next, please note that it doesn't make much sense to map variables at specific addresses unless they are either hardware registers or non-volatile variables residing in flash or EEPROM.

If the contents of such a memory location will change during execution, because it is a register, or because your program contains a bootloader/NVM programming algorithm changing NVM memory cells, then the variables must be declared as volatile. Otherwise the compiler will break your code completely upon optimization.

The particular compiler most likely has a non-standard way to allocate variables at specific addresses, such as a #pragma or sometimes the weird, non-standard @ operator. The only sensible way you can allocate a variable at a fixed location in standard C, is this:

#define MY_REGISTER (*(volatile uint8_t*)0x12345678u)

where 0x12345678 is the address where 1 byte of that is located. Once you have a macro declaration like this, you can use it as if it was a variable:

void func (void)
{
  MY_REGISTER = 1;  // write
  int var = MY_REGISTER;  // read
}

Most often you want these kind of variables to reside in the global namespace, hence the macro. But if you for some reason want the scope of the variable to be reduced, then skip the macro and access the address manually inside the code:

void func (void)
{
  *(volatile uint8_t*)0x12345678u = 1; // write
  int var = *(volatile uint8_t*)0x12345678u; // read
}

Upvotes: 17

SomeWittyUsername
SomeWittyUsername

Reputation: 18348

Like was mentioned in other answers - you can't. But, you can have a workaround. If it's ok for the globals to be initialized in the main(), you can do something of this kind:

int addr = 0xff520000;

int main()
{
    *((int*)addr) = 42;
    ...
    return 0;
}

Note, however, that this is very dependent on your system and if running in protected environment, you'll most likely get a runtime crash. If you're in embedded/non-protected environment, this can work.

Upvotes: 3

SteveP
SteveP

Reputation: 19093

You can declare a pointer to a specific memory address, and use the contents of that pointer as a variable I suppose:

int* myIntPointer = 0xff520000;

Upvotes: 0

Art
Art

Reputation: 20392

You can do this with some compiler extensions, but it's probably not what you want to do. The operating system handles your memory and will put things where it wants. How do you even know that the memory address you want will be mapped in your program? Ignore everything in this paragraph if you're on an embedded platform, then you should read the manual for that platform/compiler or at least mention it here so that people can give a more specific answer.

Also, static variables don't necessarily have the same address when the program runs. Many operating systems use position independent executables and randomize the address space on every execution.

Upvotes: 0

Ben Jackson
Ben Jackson

Reputation: 93710

You can do this kind of thing with linker scripts, which is quite common in embedded programming.

On a Linux system you might never get the same virtual address due to address space randomization (a security feature to avoid exploits that would rely on knowing the exact location of a variable like you describe).

If it's just a repeatable pointer you want, you may be able to map a specific address with mmap, but that's not guaranteed.

Upvotes: 8

luser droog
luser droog

Reputation: 19494

Not at the C level. If you work with assembly language, you can directly control the memory layout. But the C compiler does this for you. You can't really mess with it.

Even with assembly, this only controls the relative layout. Virtual memory may place this at any (in)convenient physical location.

Upvotes: 0

Tony The Lion
Tony The Lion

Reputation: 63190

No you cannot tell it explicitly where to store a variable in memory. Mostly because on modern systems you have many things done by the system in regards to memory, that is out of your control. Address Layout Randomization is one thing that comes to mind that would make this very hard.

Upvotes: 1

Related Questions