GCC Section will nicht

[Michael H. (Gast)]

Mein "toller" MCU hat gesplitten SRAM.

Ich habe gelesen, dass man __attribute__((section("m_data_2"))) den 
Compiler zwingen kann, Daten in einer sektion abzulegen.

Tut er aber nicht. Was soll ich tun?

[Johannes S. (Gast)]

Ist die section m_data_2 auch im Linker Script angelegt?

[Gogo (Gast)]

Linkerfile editieren?

[Michael H. (Gast)]

So versuche ich es mit den Variablen:
int variable[1000] __attribute__((section(".m_data_2")));
int variable2[1000] __attribute__((section(".m_data_2")));

Linker Skript:

/* Specify the memory areas */
MEMORY
{
  m_interrupts          (RX)  : ORIGIN = 0x00000000, LENGTH = 0x00000400
  m_flash_config        (RX)  : ORIGIN = 0x00000400, LENGTH = 0x00000010
  m_text                (RX)  : ORIGIN = 0x00000410, LENGTH = 0x0003FBF0
  m_data                (RW)  : ORIGIN = 0x1FFFC000, LENGTH = 0x00004000
  m_data_2              (RW)  : ORIGIN = 0x20000000, LENGTH = 0x00004000
}

[Gogo (Gast)]

Was bringt der denn für einen Output der Compiler?

Michael H. schrieb:
> Tut er aber nicht.

Woran machst Du das fest? MemDump`?

[Johannes S. (Gast)]

oder was sagt das mapfile?

[STM Apprentice (Gast)]

Michael H. schrieb:
> Linker Skript:

Das allein genügt nicht. Man braucht einen Eintrag im Bereich

SECTIONS
{
 .......
}

analog zum "normalen" RAM. Der Eintrag besagt wie der Linker
das RAM nutzen kann. Details wird sicherlich noch jemand posten
der sich bessser damit auskennt.

Inititalisierung beim Startup ist dann noch ein spezielleres Thema.

[Rufus Τ. F. (rufus)]

Michael H. schrieb:
> m_data                (RW)  : ORIGIN = 0x1FFFC000, LENGTH = 0x00004000
> m_data_2              (RW)  : ORIGIN = 0x20000000, LENGTH = 0x00004000

Da beide RAM-Bereiche aufeinanderfolgen - müssen die denn 
unterschiedlich sein?

Das Leben dürftest Du Dir einfacher machen mit

> m_data                (RW)  : ORIGIN = 0x1FFFC000, LENGTH = 0x00008000


Oder was hab' ich nicht verstanden?

[ui (Gast)]

Rufus Τ. F. schrieb:
> Michael H. schrieb:
>> m_data                (RW)  : ORIGIN = 0x1FFFC000, LENGTH = 0x00004000
>> m_data_2              (RW)  : ORIGIN = 0x20000000, LENGTH = 0x00004000
>
> Da beide RAM-Bereiche aufeinanderfolgen - müssen die denn
> unterschiedlich sein?
>
> Das Leben dürftest Du Dir einfacher machen mit
>
>> m_data                (RW)  : ORIGIN = 0x1FFFC000, LENGTH = 0x00008000
>
> Oder was hab' ich nicht verstanden?

Seh ich genauso.
Wenn du uns noch über deine MCU aufklärst, kann mans dir sogar genau 
sagen.

[Michael H. (Gast)]

Woran mache ich das fest?
>`m_data' overflowed by 4660 bytes

Wenn er eine Sektion in den Ram schreiben würde, dann wären das 4000 
bytes weniger.

Habe nun die Lösung gefunden: Man muss die Sektion im Linkerfile 
definieren, und zwar mir (siehe unten). Dann kann man über .SecRam 
darauf zugreifen.

    .SecRam  :
  {
  *(.myvars*);
  } > m_data_2

Danke an alle für den Support.

[Michael H. (Gast)]

Das ganze ist der Freescale MKE14F.

Angeblich würde man einen HardFault bekommen wenn der DMA an der grenze 
Ankommen würde. Eine Lösung wäre eine Variable an die Grenze zu legen. 
Z.B. uint8_t blocker=1;
Aber wie sage ich Gcc dass er das an diese Adresse 0x20...0 legen muss?

[Johann L. (gjlayde)]

Wenn du 2 RAM-Bereiche hast dann brauchst du möglicherweise auch einen 
extra Start-Up Code, der die beiden Bereiche initialisiert.

[Markus F. (mfro)]

Michael H. schrieb:
> Angeblich würde man einen HardFault bekommen wenn der DMA an der grenze
> Ankommen würde

Dann gehört das m.E. wohl eher nicht ins Linker-Script, sondern in die 
DMA-Initialisierung.

Wenn ein DMA-Transfer die Grenze überschreiten würde, mußt Du ihn eben 
in zwei Transfers aufteilen.

[Μαtthias W. (matthias)]

Rufus Τ. F. schrieb:
> Michael H. schrieb:
>> m_data                (RW)  : ORIGIN = 0x1FFFC000, LENGTH = 0x00004000
>> m_data_2              (RW)  : ORIGIN = 0x20000000, LENGTH = 0x00004000
>
> Da beide RAM-Bereiche aufeinanderfolgen - müssen die denn
> unterschiedlich sein?
>
> Das Leben dürftest Du Dir einfacher machen mit
>
>> m_data                (RW)  : ORIGIN = 0x1FFFC000, LENGTH = 0x00008000
>
>
> Oder was hab' ich nicht verstanden?

Kommt auf die Anwendung an. Einige Cortexe teilen das RAM bei 
0x20000000. Und je nach Anwendung kann das erhebliche Einflüsse auf die 
gesamtperformance haben wo man welche Dinge anlegt.