AVR-GCC Linker Symbol als Initializer verwenden

Jay K. (deeplyembedded) 22.03.2019 19:20 #5781232

Lesenswert?

•

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

Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat

Oliver S. (oliverso) 22.03.2019 19:37 #5781251

Lesenswert?

•

▲
▼

Mal ohne & probiert?

Oliver

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Jay K. (deeplyembedded) 22.03.2019 19:48 #5781261

Lesenswert?

•

▲
▼

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

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Dr. Sommer Gast 22.03.2019 20:14 #5781288

Lesenswert?

•

▲
▼

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...

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Jay K. (deeplyembedded) 22.03.2019 20:35 #5781316

Lesenswert?

•

▲
▼

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

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Tassilo H. (tassilo_h) 22.03.2019 20:36 #5781318

Lesenswert?

•

▲
▼

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:

  .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?

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

deeplyembedded Gast 22.03.2019 20:43 #5781328

Lesenswert?

•

▲
▼

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?

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Tassilo H. (tassilo_h) 22.03.2019 20:56 #5781338

Lesenswert?

•

▲
▼

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?!

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Jay K. (deeplyembedded) 22.03.2019 21:02 #5781347

Lesenswert?

•

▲
▼

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?

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Daniel A. (daniel-a) 22.03.2019 21:21 #5781365

Lesenswert?

•

▲
▼

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);

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Jay K. (deeplyembedded) 22.03.2019 21:50 #5781410

Lesenswert?

•

▲
▼

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;

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

Dr. Sommer Gast 25.03.2019 09:01 #5784072

Lesenswert?

•

▲
▼

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;

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat

AVR-GCC Linker Symbol als Initializer verwenden

Antwort schreiben