Accéder aux symboles définis dans le script de l'éditeur de liens par application

C'est un peu vieux, mais je vais répondre à ça de toute façon...

De la ld manuel:

De l'accès à un linker script variable définie à partir du code source est
pas intuitif. En particulier, un linker script symbole n'est pas
équivalent à une déclaration de variable dans un langage de haut niveau,
c'est plutôt un symbole qui n'ont pas de valeur.

Avant d'aller plus loin, il est important de noter que les compilateurs
souvent de transformer les noms dans le code source dans des noms différents
lorsqu'ils sont stockés dans la table des symboles. Par exemple, Fortran
les compilateurs couramment ajouter ou ajouter un trait de soulignement, et C++
effectue une vaste name mangling. Par conséquent, il pourrait être une
divergence entre le nom d'une variable tel qu'il est utilisé dans
le code source et le nom de la même variable, telle qu'elle est définie
dans un linker script. Par exemple en C, une variable de script de l'éditeur de liens
peut être appelé:

extern int foo;

Mais dans le linker script, il peut être défini comme:

_foo = 1000;

Dans les autres exemples, on suppose cependant qu'aucun nom n'
la transformation a eu lieu.

Quand un symbole est déclaré dans un langage de haut niveau comme le C,
deux choses se produisent. La première est que le compilateur réserve
assez d'espace dans la mémoire du programme pour tenir le valeur de
le symbole. La deuxième est que le compilateur crée une entrée
dans le programme de la table des symboles qui détient le symbole de la adresse.
c'est à dire le symbole de la table contient l'adresse du bloc de mémoire
maintenant le symbole de la valeur. Ainsi, par exemple, à la suite de C
déclaration, à la portée du fichier:

int foo = 1000;

crée une entrée qui s'appelle "toto" dans la table des symboles. Cette entrée
contient l'adresse d'un int taille du bloc de mémoire où l'
nombre 1000 est d'abord stockée.

Lorsqu'un programme fait référence à un symbole le compilateur génère du code
cette première accède à la table des symboles pour trouver l'adresse de la
symbole du bloc de mémoire et puis le code pour lire la valeur de cette
bloc de mémoire. Donc:

foo = 1;

regarde le symbole de foo dans la table des symboles, obtient l'adresse
associé à ce symbole, puis écrit la valeur 1 dans
cette adresse. Considérant ce qui suit:

int * a = & foo;

regarde le symbole de foo dans la table des symboles, il obtient l'adresse
puis copier cette adresse dans le bloc de mémoire associés
avec la variable "a".

Linker scripts symbole déclarations, en revanche, créer une entrée
dans la table des symboles, mais ne pas attribuer toute la mémoire. Ainsi
ils sont une adresse sans valeur. Ainsi, par exemple, l'éditeur de liens
définition du script:

foo = 1000;

crée une entrée dans la table des symboles appelés @samp{foo} qui détient
l'adresse de l'emplacement mémoire 1000, mais rien de spécial n'est stockée
à l'adresse 1000. Cela signifie que vous ne pouvez pas accéder à la valeur de
un linker script défini symbole - il n'a pas de valeur - tout ce que vous pouvez faire
c'est d'utiliser le adresse d'un linker script défini symbole.

C'est pourquoi, lorsque vous utilisez un linker script symbole défini dans la source
de code que vous devez toujours prendre l'adresse du symbole, et de ne jamais
tenter d'utiliser sa valeur. Par exemple, supposons que vous voulez copier
le contenu d'une section de la mémoire appelée .ROM dans une section
appelé .FLASH et le linker script contient ces déclarations:

start_of_ROM   = .ROM;
end_of_ROM     = .ROM + sizeof (.ROM) - 1;
start_of_FLASH = .FLASH;

Puis le code source C pour effectuer la copie serait:

extern char start_of_ROM, end_of_ROM, start_of_FLASH;

memcpy (& start_of_FLASH, & start_of_ROM, & end_of_ROM - & start_of_ROM);

Notez l'utilisation de la "&" les opérateurs. Ils sont corrects.

Code ci-dessous devrait fonctionne comme prévu:

extern const volatile unsigned int _region_RAM_start__;

extern const volatile unsigned int _region_RAM_end__;

....
int GetRAMSize()

{

int size = 0;

unsigned int address_1 = &_region_RAM_start__;

unsigned int address_2 = &_region_RAM_end__;

size = address_2 - address_1 + 1U;

return size;

}