Überlauf, nur wo?

[olpo (Gast)]

Hallo,

ich habe eine Überlauf und bekomme den nicht weg.
Mein Programm ist ca. 1000 Zeilen groß. Allerdings läuft das Programm 
nicht lange, nach wenigen Funktionen ist schluss.
Ich habe alle malloc()'s wieder ge-free()'d. Das sind auch nur kleine 
malloc()'s von höchstens 20Byte, und auch nur wenige an der Zahl.

Hier ein bißchen Code, was passiert:

NODE global_node;

void rotz(){

  NODE* local_node;

  local_node = &global_node;

  printf("globus %x  locus %x, &global_node,local_node);

Beim ersten Mal geht noch alles gut. Nach einer Zeit rufe ich die 
Funktion wieder auf, und die Ausgaben der Adresse von locus ist für'n 
Lokus.
Die Adresse von global_node stimmt hingegen immer noch.
Die Adresse von local_node ist ganz klein ( 0x20), während die von 
global_node groß ist, 0x453453 (oder so).

Also, Überlauf, oder?

Aber am Heap kann's nicht liegen. Egal ob der "nur" 0x400 Byte oder 
0x5'000
Byte groß ist. Immer spinnt der an der selben Stelle. Auch die 
Stack-Größe ändern bringt nichts.

Tja, ich weiß nicht weiter. Ich sitze schon seit sieben Stunden daran.


Mein Projekt:
  Xilinx
  Microblaze
  BRAM 0x10'000
  Standalone oder Xilkernel ( beides gleicher Fehler)
  C-Code

[Karl H. (kbuchegg)]

Überprüf mal alle deine Arrayzugriffe ob du irgendwo Out Of Bounds 
schreibst.

[olpo (Gast)]

Na gut, werde gucken;

aber kann das wirklich sein?

Da läuft kein Thread oder so, sondern alles schön iterativ. Und die 
beiden Zeilen stehen direkt untereinander. Wie kann denn eine Zuweisung 
schiefgehen?

local_node = &global_node;
  printf("globus %x  locus %x", &global_node, local_node);

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Verwende doch mal %p anstatt %x, poste mal die Werte vom ersten
Durchlauf und dem wo es klemmt.

[Karl H. (kbuchegg)]

olpo schrieb:

> Da läuft kein Thread oder so, sondern alles schön iterativ. Und die
> beiden Zeilen stehen direkt untereinander. Wie kann denn eine Zuweisung
> schiefgehen?

Dein eigentliches Problem sitzt ganz woanders.
Was du siehst sind die Symptome, aber nicht die Ursachen.

[Joachim D. (Firma: JDCC) (scheppertreiber)]

local_node = &global_node;
 printf("globus %x  locus %x, &global_node,local_node);

Eigentlich müßten ja beide Werte gleich sein. Denkbar, daß %x auf
dem System eben nicht der Wert des kompletten Pointers ist.

Außerdem fehlt ein Hühnerfuß, das kann so nicht mal kompiliert werden.

[olpo (Gast)]

ich glaube %p kann xil_printf nicht.
Aber, wenn ich stattdessen printf() verwende, bekomme ich eine schöne 
Fehlermeldung:

c:\xilinx\13.3_3\sdk\sdk\gnu\microblaze\nt64\bin\..\lib\gcc\microblaze-xilinx-elf\4.1.2\..\..\..\..\microblaze-xilinx-elf\bin\ld.exe: section .ctors [000000b0 -> 000000b7] overlaps section .text [00000050 -> 0001445b]

Kann es sein, dass .text zur Laufzeit überläuft?

Wenn ja, wie kann ich die Größe von .text ändern? Einfach den Heap 
verkleinern reicht nicht, wie ich ausprobiert habe.

Hier das Kauderwelsch von LinkScript

/*******************************************************************/
/*                                                                 */
/* This file is automatically generated by linker script generator.*/
/*                                                                 */
/* Version: Xilinx EDK 13.3 EDK_O.76xd                                */
/*                                                                 */
/* Copyright (c) 2010 Xilinx, Inc.  All rights reserved.           */
/*                                                                 */
/* Description : MicroBlaze Linker Script                          */
/*                                                                 */
/*******************************************************************/

_STACK_SIZE = DEFINED(_STACK_SIZE) ? _STACK_SIZE : 0x400;
_HEAP_SIZE = DEFINED(_HEAP_SIZE) ? _HEAP_SIZE : 0x400;

/* Define Memories in the system */

MEMORY
{
   ilmb_cntlr_CI_dlmb_cntlr_CI : ORIGIN = 0x00000050, LENGTH = 0x0000FFB0
   DDR2_SDRAM_MPMC_BASEADDR : ORIGIN = 0x90000000, LENGTH = 0x10000000
}

/* Specify the default entry point to the program */

ENTRY(_start)

/* Define the sections, and where they are mapped in memory */

SECTIONS
{
.vectors.reset 0x00000000 : {
   *(.vectors.reset)
} 

.vectors.sw_exception 0x00000008 : {
   *(.vectors.sw_exception)
} 

.vectors.interrupt 0x00000010 : {
   *(.vectors.interrupt)
} 

.vectors.hw_exception 0x00000020 : {
   *(.vectors.hw_exception)
} 

.text : {
   *(.text)
   *(.text.*)
   *(.gnu.linkonce.t.*)
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.init : {
   KEEP (*(.init))
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.fini : {
   KEEP (*(.fini))
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.ctors : {
   __CTOR_LIST__ = .;
   ___CTORS_LIST___ = .;
   KEEP (*crtbegin.o(.ctors))
   KEEP (*(EXCLUDE_FILE(*crtend.o) .ctors))
   KEEP (*(SORT(.ctors.*)))
   KEEP (*(.ctors))
   __CTOR_END__ = .;
   ___CTORS_END___ = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.dtors : {
   __DTOR_LIST__ = .;
   ___DTORS_LIST___ = .;
   KEEP (*crtbegin.o(.dtors))
   KEEP (*(EXCLUDE_FILE(*crtend.o) .dtors))
   KEEP (*(SORT(.dtors.*)))
   KEEP (*(.dtors))
   __DTOR_END__ = .;
   ___DTORS_END___ = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.rodata : {
   __rodata_start = .;
   *(.rodata)
   *(.rodata.*)
   *(.gnu.linkonce.r.*)
   __rodata_end = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.sdata2 : {
   . = ALIGN(8);
   __sdata2_start = .;
   *(.sdata2)
   *(.sdata2.*)
   *(.gnu.linkonce.s2.*)
   . = ALIGN(8);
   __sdata2_end = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.sbss2 : {
   __sbss2_start = .;
   *(.sbss2)
   *(.sbss2.*)
   *(.gnu.linkonce.sb2.*)
   __sbss2_end = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.data : {
   . = ALIGN(4);
   __data_start = .;
   *(.data)
   *(.data.*)
   *(.gnu.linkonce.d.*)
   __data_end = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.got : {
   *(.got)
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.got1 : {
   *(.got1)
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.got2 : {
   *(.got2)
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.eh_frame : {
   *(.eh_frame)
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.jcr : {
   *(.jcr)
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.gcc_except_table : {
   *(.gcc_except_table)
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.sdata : {
   . = ALIGN(8);
   __sdata_start = .;
   *(.sdata)
   *(.sdata.*)
   *(.gnu.linkonce.s.*)
   __sdata_end = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.sbss : {
   . = ALIGN(4);
   __sbss_start = .;
   *(.sbss)
   *(.sbss.*)
   *(.gnu.linkonce.sb.*)
   . = ALIGN(8);
   __sbss_end = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.tdata : {
   __tdata_start = .;
   *(.tdata)
   *(.tdata.*)
   *(.gnu.linkonce.td.*)
   __tdata_end = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.tbss : {
   __tbss_start = .;
   *(.tbss)
   *(.tbss.*)
   *(.gnu.linkonce.tb.*)
   __tbss_end = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.bss : {
   . = ALIGN(4);
   __bss_start = .;
   *(.bss)
   *(.bss.*)
   *(.gnu.linkonce.b.*)
   *(COMMON)
   . = ALIGN(4);
   __bss_end = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

_SDA_BASE_ = __sdata_start + ((__sbss_end - __sdata_start) / 2 );

_SDA2_BASE_ = __sdata2_start + ((__sbss2_end - __sdata2_start) / 2 );

/* Generate Stack and Heap definitions */

.heap : {
   . = ALIGN(8);
   _heap = .;
   _heap_start = .;
   . += _HEAP_SIZE;
   _heap_end = .;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

.stack : {
   _stack_end = .;
   . += _STACK_SIZE;
   . = ALIGN(8);
   _stack = .;
   __stack = _stack;
} > ilmb_cntlr_CI_dlmb_cntlr_CI

_end = .;
}

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Meinst DU hilft uns besser wie der Quellcode ?
Du hast den ja sogar falsch abgetippt ;)

[olpo (Gast)]

typedef struct resource_NODE{
  Xuint32 resource_id;
  Xuint8  t_c_id;
  struct tcid_NODE* connected_tcids;
  Xuint8* session_list;
  Xuint32 session_list_size;
  struct resource_NODE* next;
}resource_NODE;


resource_NODE resource_list = {0, 0, NULL, 0, NULL};


Xuint8 setSession( Xuint32 resource_id, Xuint16* session_nb, Xuint8 tc_id ){

    int i;
    *session_nb = 1;

    resource_NODE* resource;

    resource->next = &resource_list;
    xil_printf("next %x &resource_list %x\n\r",resource->next, &resource_list);

  while( resource->next != NULL){
...

[Karl H. (kbuchegg)]

olpo schrieb:

>     resource_NODE* resource;
>
>     resource->next = &resource_list;

Autsch.

Nun hab dich nicht so. Willst du deinen Fehler finden oder nicht? SOllen 
wir dir dabei helfen oder nicht?

Wenn du beide Fragen mit 'Ja' beantwortest, dann hör auf hier 
Phantasiecode zu posten, der voller Fehler ist. Hier hat nämlich keiner 
Lust, Phantomfehlern nachzulaufen.

Und wenn das da tatsächlich der Anfang der Funktion ist, dann wundert 
mich nichts mehr. Schnelle Frage: Auf welches resource_NODE element 
zeigt denn der Pointer resource, dessen next Feld du veränderst?

[Rolf M. (rmagnus)]

olpo schrieb:
> resource_NODE* resource;

Hier hast du einen Zeiger, den du nicht initialisierst.

>     resource->next = &resource_list;

Hier dereferenzierst du ihn. Du schreibst "in die Pampa".

[olpo (Gast)]

Hups...ist kein Fantasie-Code. Ich bin so.. :)

So besser?

resource_NODE resource;

resource.next = &resource_list;

[Karl H. (kbuchegg)]

olpo schrieb:
> Hups...ist kein Fantasie-Code. Ich bin so.. :)
>
> So besser?
kommt drauf an wies weitergeht.

Was wird das hier: Programmieren per Ratespiel?

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Karl Heinz Buchegger schrieb:
> Was wird das hier: Programmieren per Ratespiel?

Sieht so aus ;)

Es gibt auch bei C manchmal ganz nette Seiteneffekte. Das sieht man
leider nur im Zusammenhang. Den Codeschnippseln nach frißt das eh
kein Compiler ...

[Karl H. (kbuchegg)]

Joachim Drechsel schrieb:
> Karl Heinz Buchegger schrieb:
>> Was wird das hier: Programmieren per Ratespiel?
>
> Sieht so aus ;)

Ich nehm den 50:50 Joker

> Es gibt auch bei C manchmal ganz nette Seiteneffekte. Das sieht man
> leider nur im Zusammenhang. Den Codeschnippseln nach frißt das eh
> kein Compiler ...

Den Codeschnipseln nach würd ich dem TO dringend ein paar 
Trainingseinheiten zum Thema "dynamic data structures" auf dem PC 
empfehlen. Mit besonderem Augenmerk auf penibler NULL-Initialisierung 
ausnahmslos ALLER Pointer.

[olpo (Gast)]

Jaja, amüsiert euch nur...

Wie ist das bei malloc()?

Das liefert ja auch nur einen Pointer zurück. Kann ich das dann gleich 
nutzen, oder muss ich das zuerst auch mit "was konkreten" füllen?

Also,

struct struktur{
  int a;
  int b;
};

void bla(){

  struktur* s = malloc(sizeof(struktur));

/* dann sollte ich das wohl nicht machen */

  s->a = 1234;

/* sondern zuerst initialisieren? */

  struktur init;

  *s = init;

  init.a = 1234;

[Karl H. (kbuchegg)]

olpo schrieb:
> Jaja, amüsiert euch nur...

Wir amüsieren uns nicht.
Ganz im Gegenteil.

> Wie ist das bei malloc()?

Es liefert einen Pointer auf einen entsprechend großen Speicherbereich.

> Das liefert ja auch nur einen Pointer zurück. Kann ich das dann gleich
> nutzen, oder muss ich das zuerst auch mit "was konkreten" füllen?

Da fehlts jetzt aber arg weit.

> Also,
> [c]struct struktur{
>   int a;
>   int b;
> };
>
> void bla(){
>
>   struktur* s = malloc(sizeof(struktur));
>
> /* dann sollte ich das wohl nicht machen */
>
>   s->a = 1234;

doch, das ist fein.
Du hast einen Pointer und der zeigt auf Speicher in dem ein struktur 
Objekt existiert.

>
> /* sondern zuerst initialisieren? */
>
>   struktur init;

Und wie machst du die Initialisierung?
Richtig. Mit Zuweisungen. Womit wir wieder bei der Variante 1 wären.

>   *s = init;

Das ist auch nichts anderes als eine Zuweisung. Nur dass du eine 
komplette Struktur in einem Rutsch auf den Speicher kopierst wo der 
Zeiger hinzeigt und in der Variante 1 kopierst du in Häppchen Member für 
Member.

[Peter D. (peda)]

olpo schrieb:
> Ich habe alle malloc()'s wieder ge-free()'d. Das sind auch nur kleine
> malloc()'s von höchstens 20Byte

Ich kann mir nicht vorstellen, daß das mächtige malloc-Geschütz für nur 
einige 20Byte überhaupt einen Sinn macht.
Warum kannst Du die Variablen nicht einfach schon zur Compilezeit 
reservieren?

Nicht alle Techniken, die auf einem PC mit vielen GB RAM Sinn machen, 
muß man auch einem MC aufzwingen.

20 Byte würde allerdings auch auf dem PC niemand mit malloc anlegen. Der 
Verwaltungsaufwand wird schon ein Mehrfaches betragen. Häppchen unter 
1kB lohnen sich dann nicht.


Peter