So platzieren Sie eine Variable an einer bestimmten absoluten Adresse im Speicher (mit GCC)

Question 1

Der RealView ARM C-Compiler unterstützt Platzieren einer Variablen an einer gegebenen Speicheradresse unter Verwendung des Variablenattributs at(address):

int var __attribute__((at(0x40001000)));
var = 4;   // changes the memory located at 0x40001000

Hat GCC ein ähnliches Variablenattribut?

Question 2

Ich weiß es nicht, aber Sie können leicht eine Problemumgehung wie folgt erstellen:

int *var = (int*)0x40001000;
*var = 4;

Es ist nicht exakt das gleiche, aber in den meisten Situationen ein perfekter Ersatz. Es funktioniert mit jedem Compiler, nicht nur mit GCC.

Wenn Sie GCC verwenden, gehe ich davon aus, dass Sie es auch verwenden GNU-ld (obwohl es natürlich keine Gewissheit ist) und ld unterstützt das Platzieren von Variablen wo immer du sie willst.

Ich stelle mir vor, dass es ziemlich üblich ist, den Linker diese Arbeit erledigen zu lassen.

Inspiriert von der Antwort von @rib füge ich hinzu, dass ich hinzufügen würde, wenn die absolute Adresse für ein Steuerregister bestimmt ist volatile zur Zeigerdefinition. Wenn es nur RAM ist, spielt es keine Rolle.

Question 3

Du könntest die verwenden Abschnittsattribute und ein ld Linker-Skript um die gewünschte Adresse für diesen Abschnitt zu definieren. Dies ist wahrscheinlich chaotischer als Ihre Alternativen, aber es ist eine Option.

Question 4

Beispiel für ein minimales lauffähiges Linker-Skript

Die Technik wurde erwähnt unter: https://stackoverflow.com/a/4081574/895245 aber jetzt werde ich jetzt ein konkretes Beispiel liefern.

Haupt c

#include <stdio.h>

int myvar __attribute__((section(".mySection"))) = 0x9ABCDEF0;

int main(void) {
    printf("adr %p\n", (void*)&myvar);
    printf("val 0x%x\n", myvar);
    myvar = 0;
    printf("val 0x%x\n", myvar);
    return 0;
}

link.ld

SECTIONS
{
  .mySegment 0x12345678 : {KEEP(*(.mySection))}
}

GitHub-Upstream.

Kompilieren und ausführen:

gcc -fno-pie -no-pie -o main.out -std=c99 -Wall -Wextra -pedantic link.ld main.c
./main.out

Ausgabe:

adr 0x12345678
val 0x9abcdef0
val 0x0

Wir sehen also, dass es an der gewünschten Adresse abgelegt wurde.

Ich kann nicht finden, wo dies im GCC-Handbuch dokumentiert ist, aber die folgende Syntax:

gcc link.ld main.c

scheint das angegebene Linker-Skript an das Standardskript anzuhängen, das verwendet werden würde.

-fno-pie -no-pie ist erforderlich, da die Ubuntu-Toolchain jetzt standardmäßig so konfiguriert ist, dass sie ausführbare PIE-Dateien generiert, was dazu führt, dass der Linux-Kernel die ausführbare Datei jedes Mal an einer anderen Adresse ablegt, was unser Experiment durcheinander bringt. Siehe auch: Was ist die Option -fPIE für positionsunabhängige ausführbare Dateien in gcc und ld?

TODO: Kompilierung erzeugt eine Warnung:

/usr/bin/x86_64-linux-gnu-ld: warning: link.ld contains output sections; did you forget -T?

Mache ich etwas falsch? Wie kann man es loswerden? Siehe auch: So entfernen Sie die Warnung: link.res enthält Ausgabeabschnitte; hast du vergessen -T?

Getestet auf Ubuntu 18.10, GCC 8.2.0.

Question 5

Sie haben Ihre Frage beantwortet. In Ihrem obigen Link heißt es:

Mit dem GNU GCC Compiler können Sie nur Zeigerdefinitionen verwenden, um auf absolute Speicherstellen zuzugreifen. Zum Beispiel:

#define IOPIN0         (*((volatile unsigned long *) 0xE0028000))
IOPIN0 = 0x4;

Übrigens http://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/Variable-Attributes.html#Variable%20Attributes

Question 6

    extern const uint8_t dev_serial[12];
    asm(".equ dev_serial, 0x1FFFF7E8");
/* or    asm("dev_serial = 0x1FFFF7E8"); */
    ...

    for (i = 0 ; i < sizeof(dev_serial); i++)
        printf((char *)"%02x ", dev_serial[i]);

Question 7

In GCC können Sie Variablen in bestimmten Abschnitten platzieren:

__attribute__((section (".foo"))) static uint8_t * _rxBuffer;

oder

static uint8_t * _rxBuffer __attribute__((section (".foo")));

und geben Sie dann die Adresse des Abschnitts in den GNU Linker Memory Settings an:

.foo=0x800000

Question 8

Ich hatte ein ähnliches Problem. Ich wollte eine Variable in meinem definierten Abschnitt an einem speziellen Offset zuweisen. Gleichzeitig wollte ich, dass der Code portabel ist (keine explizite Speicheradresse in meinem C-Code). Also habe ich den RAM-Abschnitt im Linker-Skript definiert und ein Array mit der gleichen Länge meines Abschnitts definiert (.noinit Abschnitt hat eine Länge von 0x0F).

uint8_t no_init_sec[0x0f] __attribute__ ((section (".noinit")));

Dieses Array bildet alle Orte dieses Abschnitts ab. Diese Lösung ist nicht geeignet, wenn der Abschnitt groß ist, da die ungenutzten Stellen in dem zugewiesenen Array ein verschwendeter Platz im Datenspeicher sind.