Auto-Allocate to a specific RAM Area in GCC/C

Question

Sorry for my english, its a bit hard for me to explain what exactly i would need. I'm making some extra code into existing binarys using the GCC compiler. In this case, its PowerPC, but it should not really matter.

I know, where in the existing binary i have free ram available (i dumped the full RAM to make sure) but i need to define each RAM address manually, currently i am doing it like this:

// #ram.h

//8bit ram
uint8_t*        xx1     = (uint8_t*)    0x807F00;
uint8_t*        xx2     = (uint8_t*)    0x807F01;
//...and so on

// 16bit ram
uint16_t*       xxx1    = (uint16_t*)   0x807F40;
uint16_t*       xxx2    = (uint16_t*)   0x807F42;
//...and so on
    
// 32bit ram
uint32_t*       xxxx1   = (uint32_t*)   0x807FA0;
uint32_t*       xxxx2   = (uint32_t*)   0x807FA4;
//...and so on

And im accessing my variables like this:

void  __attribute__ ((noinline)) silly_demo_function() {
    #include "ram.h"
    
    if (*xxx2>*xx1) {
    *xxx3 = *xxx3 + *xx1; 
    }
    
return; 
}

But this gets really boring, if i want to patch my code into another existing binary, where the location of available/free/unused ram can be fully different, or if im replacing/removing some value in the middle. I am using 8, 16 and 32bit variables.

Is there a way, i can define an area like 0x807F00 to 0x00808FFF, and allocate my variables on the fly, and the compiler will allocate it inside my specific location?

Answer 1

I suspect that the big problem here is that those addresses are memory mapped IO (devices) and not RAM; and should not be treated as RAM.

Further, I'd say that you probably should be hiding the "devices that aren't RAM" behind an abstract layer, a little bit like a device driver; partly so that you can make sure that the compiler complies with any constraints caused by it being IO and not RAM (e.g. treated as volatile, possibly honoring any access size restrictions, possibly taking care of any cache coherency management); partly so that you/programmers know what is normal/fast/cached RAM and what isn't; partly so that you can replace the "device" with fake code for testing; and partly so that it's all kept in a single well defined area.

For example; you might have a header file called "src/devices.h" that contains:

#define xx1_address  0x807F00

..and the wrapper code might be a file called "src/devices/xx1.c" that contains something like:

#include "src/devices.h"


static volatile uint8_t * xx1  = (uint8_t*) xx1_address;


uint8_t get_xx1(void) {
    return *xx1;
}

void set_xx1(uint8_t x) {
    *xx1 = x;
}

However; depending on what these devices actually are, you might need/want some higher level code. For example, maybe xx1 is a temperature sensor and it doesn't make any sense to try to set it, and you want it to scale that raw value so it's "degrees celsius", and the highest bit of the raw value is used to indicate an error condition (and the actual temperature is only 7 bits), so the wrapper might be more like:

#include "src/devices.h"

#define xx1_offset   -12.34
#define xx1_scale    1.234

static volatile uint8_t * xx1  = (uint8_t*) xx1_address;


float get_xx1_temperature(void) {
    uint8_t raw_temp = *xx1;

    if(raw_temp * 0x80 != 0) {
        /* Error flag set */
        return NAN;
    }
    /* No error */
    return (raw_temp + xx1_offset) * xx1_scale;
}