C Recursive Macros for table offsets - c

Question

We need to create a static table of addresses for an external memory.
The size of the stored structures is known and fixed. However, the addresses of these structures must start at the beginning of a memory section.
We intended to do this by using macros, because lets the table change as the elements of the table change at compile time.
The implementation looks something like this:
#define BLOC (0xFF)
#define FINAL_ADR(N) (ADR_##N + SIZE_##N)
#define GET_ADR(N) (FINAL_ADR(N) + (BLOC - (FINAL_ADR(N) & BLOC)))
#define ADR_0 (0x0)
#define SIZE_0 (5)
#define ADR_1 GET_ADR(0)
#define SIZE_1 (300)
#define ADR_2 GET_ADR(1)
#define SIZE_2 (130)
...
const struct {
uint32_t addr, size;
} mem[] = {
{.addr = ADR_0, .size = SIZE_0},
{.addr = ADR_1, .size = SIZE_1},
{.addr = ADR_2, .size = SIZE_2},
};
The code above tries to assign an address from the previous address and size of element.
Element 0 starts at position 0x00 and ocupes 5 bytes (1 section).
Element 1 should start at position 0xFF and ocupes 300 bytes (2 sections).
Element 2 should start at position 0x2FD and ocupes 130 bytes (1 section).
If we try to implement the macros above, the compiler fails. Because the macros are referencing themselves at the Element 2:
ADR_2 = ((GET_ADR(1)+ SIZE_1) + (0xFF- ((GET_ADR(1)+ SIZE_1) & 0xFF)))
Is it possible to circumvent this indirect self-referencing macro? Is there a better way to accomplish this?

Answer 1

You can abuse an enumeration to get this.
#include <stdint.h>
#define BLOC (0xFF)
#define FINAL_ADR(N) (ADR_##N + SIZE_##N)
#define GET_ADR(N) (FINAL_ADR(N) + (BLOC + 1 - (FINAL_ADR(N) & BLOC)))
enum {
ADR_0 = 0x0, SIZE_0 = 5,
ADR_1 = GET_ADR(0), SIZE_1 = 300,
ADR_2 = GET_ADR(1), SIZE_2 = 130,
};
const struct {
uint32_t addr, size;
} mem[] = {
{.addr = ADR_0, .size = SIZE_0},
{.addr = ADR_1, .size = SIZE_1},
{.addr = ADR_2, .size = SIZE_2},
};
Compiled to assembler source (for x86_64):
.text
.section .rdata,"dr"
.globl mem # #mem
.p2align 4
mem:
.long 0 # 0x0
.long 5 # 0x5
.long 256 # 0x100
.long 300 # 0x12c
.long 768 # 0x300
.long 130 # 0x82
Oh, and your blocking formula needs that additional + 1 to reach the next multiple of 0x100.

Answer 2

This is not how you memory map variables in embedded systems.
All variables with a custom memory map gets configured in the linker script, not in the source code. You create segments (sometimes also called sections) in the linker script, where you specify the starting address and the size of each segment.
Then in the source, you use some compiler-specific non-standard extension to allocate variables inside that segment you created. Example for gcc:
struct element0 stuff __attribute__ (section ("ELEMENT_0")) = { ... };
Now if some other part of the code needs to know the address of this variable, then it can be obtained with &stuff.
In case your external memory is a serial one accessed by SPI etc and not memory mapped, then simply make a hard-coded lookup table with (named) numeric constants. No need for all these complex, unreadable macros. Good programmers write code as simple as possible, not as complicated as possible.