AVR-GCC Linker Symbol als Initializer verwenden

[Jay K. (deeplyembedded)]

Hallo zusammen,

ich möchte im Flash meines ATMEGA88 Start- und Endadresse eines 
Bereiches ablegen, über den eine CRC berechnet werden soll.
Die Adressinformation erzeuge ich über das Linkerskript mit
__CHECKSUM_START = .;
und
__CHKSUM_END = .;

Nun deklariere ich diese Symbole entsprechend mit
extern const uint32 __CHECKSUM_START;
extern const uint32 __CHKSUM_END;

Definieren möchte ich dann eine Variable mit

const uint32 PROGMEM ChksumStartAddr = &__CHECKSUM_START;

Aber der Compiler macht mir einen Strich durch die Rechnung:
error: initializer element is not computable at load time

Kann mir jemand sagen, was ich verkehrt mache?

Danke und viele Grüße

[Oliver S. (oliverso)]

Mal ohne & probiert?

Oliver

[Jay K. (deeplyembedded)]

Jap, da steigt der GCC dann aber gleich aus mit:
error: initializer element is not constant

[Dr. Sommer (Gast)]

Jay K. schrieb:
> const uint32 PROGMEM ChksumStartAddr = &__CHECKSUM_START

Welchen Sinn hat das überhaupt? Kannst du nicht einfach __CHECKSUM_START 
statt ChksumStartAddr nutzen? Ist ja eh konstant. Kann übrigens sein 
dass das in C++ geht. Probier es mal aus...

[Jay K. (deeplyembedded)]

Dr. Sommer schrieb:
> Welchen Sinn hat das überhaupt?

Der Sinn ist, dass diese Werte während des Builds vom Hauptprogramm eben 
im Flash abgelegt werden und dann zur Laufzeit von einer anderen Instanz 
(z.B. dem Bootloader) ausgelesen und zur CRC Berechnung genutzt werden 
können

[Tassilo H. (tassilo_h)]

Eigentlich müsste es gehen. Zum Vergleich, in meinem Code (ist zwar 
ARM-GCC, aber dafür spielt das ja keine Rolle) sieht das so aus:

// first address that follows the rom space used by the linker
extern uint32_t _usedromend;  
// first address that is used for the .text section by the linker 
extern uint32_t _usedromstart; 

uint32_t sysComputeFlashCRC()
{
  uint32_t *dp;

  dp = &_usedromstart;
  sysCRCReset();
  while (dp != &_usedromend) sysCRCAdd(*dp++);
  return sysCRCGet();
}

und im Linkerscript:

SECTIONS
{
  .text :
  {
  _usedromstart = .;
    KEEP(*(.isr_vector))
    *(.text*)
    *(.rodata*)
  } > rom 
  
  .ARM.exidx : 
  {
    __exidx_start = .;
    *(.ARM.exidx* .gnu.linkonce.armexidx.*)
    __exidx_end = .;
  } > rom
  
  __etext = .;
  /* _sidata is used in startup code */
  _sidata = __etext;
  .data : AT (__etext)
  {
    __data_start__ = .;
    /* _sdata is used in startup code */
    _sdata = __data_start__;
    
    *(vtable)
    *(.data*)
    . = ALIGN(4);
    /* All data end */
    __data_end__ = .;
    /* _edata is used in startup code */
    _edata = __data_end__;
  } > ram 
  /* _siccmdata is used in startup code to init vars in ccm */
  _siccmdata = __etext + SIZEOF (.data);
  .ccmdata : AT ( _siccmdata )
  {
    __ccmdata_start__ = .;
    _sccmdata = __ccmdata_start__;
    *(.ccmdata*)
    . = ALIGN(4);
    /* All data end */
     __ccmdata_end__ = .;
    _eccmdata = __ccmdata_end__;
  } > ccm
  _usedromend = _siccmdata + SIZEOF (.ccmdata);
  .bss :
  {
...

Vielleicht hilft das ja...

PS: Gerade ausprobiert:

const uint32_t *rompointer = &_usedromstart;

im Code compiliert einwandfrei. Also sollte dein Beispiel eigentlich 
auch gehen... Muss wohl eine AVR-Spezialität sein. Kannst du denn eine 
nicht-PROGMEM-Variable damit initialisieren?

[deeplyembedded (Gast)]

Hallo Tassilo,

danke für das Beispiel. So wie ich das sehe ist es nicht ganz das 
Gleiche. Du arbeitest hier mit dem Linkersymbol nach der Definition der 
(lokalen) Variablen.
Zudem ist der ARM keine Harvard-Architektur...vielleicht ist da auch ein 
Problem?

[Tassilo H. (tassilo_h)]

Habe gerade nochmal probiert:

Eine globale variable:

const uint32_t romstartadr = (uint32_t)&_usedromstart;

// uses the built in CRC engine to compute
// the CRC of the FLash
uint32_t sysComputeFlashCRC()
{
  uint32_t *dp;

  //dp = &_usedromstart;
  dp = (void*)romstartadr;
  sysCRCReset();
  while (dp != &_usedromend) sysCRCAdd(*dp++);
  return sysCRCGet();
}

funktioniert auch. Die liegt auch im Flash und nicht im RAM, da const. 
Wenn der GCC das beim ARM zur Linkzeit eintragen kann, müsste das doch 
beim AVR auch gehen?!

[Jay K. (deeplyembedded)]

Also mit einer "nicht-progmem" Variablen geht es auch nicht.
Ich habe nun folgendes probiert:

const uint32_t startaddr = __CHKSUM_START;

Funktioniert auch nicht. Fehlermeldung ist wieder
error: initializer element is not computable at load time

Ich denke wirklich, es ist hier eine AVR-GCC Spezialität

Edit:
Brauch ich noch ein spezielles Compiler-Flag oder einen zusätzlichen 
Link-Run oder so etwas?

[Daniel A. (daniel-a)]

Jay K. schrieb:
> Ich denke wirklich, es ist hier eine AVR-GCC Spezialität

Das ist keine Limitation des Compilers, sondern des Linkers. Ich glaube 
ich hatte mit const auch schon ähnliche Probleme.

Interessanter weise scheint das hier bei mir zu gehen:

#include <stdio.h>

int x __attribute__((section("testsec")));
int y __attribute__((section("testsec")));

extern char __start_testsec[];
extern char __stop_testsec[];

struct my_structure {
  void* start;
  void* end;
};

const struct my_structure testsec_info = {
  .start = __start_testsec,
  .end = __stop_testsec
};

int main(){
  printf("%p %p\n",testsec_info.start, testsec_info.end);
}

[Jay K. (deeplyembedded)]

Hallo Daniel,

vielen Dank, damit läuft es jetzt bei mir auch durch!
Geholfen hat der void* als Typ und bei der extern Deklaration das uint8 
/ char Array.

extern uint8_t __CHECKSUM_START[];
const void* ptrStartAddr = __CHECKSUM_START;

[Dr. Sommer (Gast)]

Daniel A. schrieb:
> Interessanter weise scheint das hier bei mir zu gehen:

Na sowas...

Eine andere Möglichkeit wäre, es folgendermaßen komplett übers 
Linkerscript zu machen:

.text : {
  LONG(__CHECKSUM_START)
  LONG(__CHECKSUM_END)
  . = ALIGN(4);
  __CHECKSUM_START = .;
  ...
  . = ALIGN(4);
  __CHKSUM_END = .;
}

Im C-Code braucht man gar nichts mehr zu schreiben. Wenn man die 
Adressen auslesen will kann man wie gehabt extern benutzen:

extern const uint32_t __CHECKSUM_START;
extern const uint32_t __CHKSUM_END;