In C aus Programm herausspringen

Gibt es:

break

Oder ein anderer weg ist.....

Watchdog scharf machen, die einen Reset macht.
Dann

    while(1);


Der Rest kommt alleine


Gruß Thomas

Wie immer bei solchen Fragen heißt die Gegenfrage: Warum?

Oliver

Peter S. schrieb:
> wieder zum Anfang des
> Programms zu kommen und alle folgenden Befehle zu ignorieren?

Dafür gibt es "Goto". Aber Verwendung von "Goto" ist nicht empfohlen.

Peter S. schrieb:
> Gibt es einen Befehl (bitte nur in C, da ich die Assembler Sprache
> nicht kenne), mit dem ich ungeachtet von Schleifen usw. zu einem
> bestimmten Punkt im Programm "springen" kann?

Es ist nicht möglich, in eine andere Funktion zu springen, ohne diese 
aufzurufen. Davon abgesehen wurden setjmp/longjmp bereits genannt.

Zu guter Letzt gibt es noch eine gcc-Erweiterung, mit der man die 
Adresse eines Labels nehmen kann (void *ptr = &&labelname). Die kann man 
dann direkt anspringen (goto *ptr). Ist die Adresse außerhalb der 
aktuellen Funktion, passieren komische Dinge (kaputter Stack).

Hallo,
GEKU schrieb:>
> Mit welcher Begründung?

Mit dieser Frage öffnest du gerade das Tor zur Hölle.

rhf

Karl schrieb:
> Maxim B. schrieb:
>> Aber Verwendung von "Goto" ist nicht empfohlen.
>
> Genau, führt direkt in die Hölle!!!

Aber nur mit Clang. Der derzeitige GCC meldet bei

1

  goto Hölle;

mehrere Fehler, so dass die Fahrt in die Hölle gar nicht erst gestartet
werden kann ;-)

Das wird sich aber sicher in einer zukünftigen Version ändern.

Karl schrieb:
> Genau, führt direkt in die Hölle!!!

Ja, auf einem µC schon, aber in anderen Programmen, auf dem PC, ist das 
doch sicher noch üblich, wenn das auch als schlechter Stil angesehen 
wird.
Der Zweck heiligt immer die Mittel.

1

Zur Programmierung empfiehlt es sich, die break-, continue- und return-Anweisung der goto-Anweisung vorzuziehen, wann immer dies möglich ist. Da die break-Anweisung nur eine Ebene der Schleife beendet, ist möglicherweise eine goto-Anweisung erforderlich, um die Schleife aus einer tief verschachtelten Schleife heraus zu beenden.

Wenn es sich aber um Programmierung von Mikrocontrollern handelt, sollte 
man so was tunlichst vermeiden.

Yalu X. schrieb:
> Aber nur mit Clang. Der derzeitige GCC meldet bei
>
>   goto Hölle;
>
> mehrere Fehler, so dass die Fahrt in die Hölle gar nicht erst gestartet
> werden kann ;-)

... und landet dann bei Wolfgang Petri.
Hölle, Hölle, Hölle.

GEKU schrieb:
> Z.B. wenn man aus einer Schleife aussteigen muss,  ohne den Code nach
> dem Schleifenkonstrukt zu exekutieren.

"break" reicht nicht?

HGier mal ein kleines Beispiel,

Peter S. schrieb:
> um bei bestimmen Bedingungen (wenn eine if-Abfrage wahr ist) wieder
> zum Anfang des Programms zu kommen und alle folgenden Befehle zu
> ignorieren

unter Verwendung des bereits vorgeschlagenen setjmp/longjmp:

1

#include <stdio.h>

2

#include <setjmp.h>

3

4

static jmp_buf env;

5

static int error = 1;

6

7

void sub2(void) {

8

  printf("sub2\n");

9

  if(error)

10

    longjmp(env, 1);

11

  printf("nie erreicht in sub2\n");

12

}

13

14

void sub1(void) {

15

  printf("sub1\n");

16

  sub2();

17

  printf("nie erreicht in sub1\n");

18

}

19

20

int main(void) {

21

  while(setjmp(env))

22

    printf("Neustart\n");

23

24

  printf("main\n");

25

  sub1();

26

  printf("nie erreicht in main\n");

27

}

Ausgabe:

1

main

2

sub1

3

sub2

4

Neustart

5

main

6

sub1

7

sub2

8

Neustart

9

main

10

...

Maxim B. schrieb:
> GEKU schrieb:
>> Z.B. wenn man aus einer Schleife aussteigen muss,  ohne den Code nach
>> dem Schleifenkonstrukt zu exekutieren.
>
> "break" reicht nicht?

Gibt kein 'doppelbreak' for zwei oder mehr Schleifen.

NichtWichtig schrieb:
> Oliver S. schrieb:
>> Wie immer bei solchen Fragen heißt die Gegenfrage: Warum?
>>
>> Oliver
>
> Warum willst Du das wissen?

Weil die Frage erstmal nach keiner guten Idee klingt und weil sie zu 
allgemein formuliert ist. Um eine optimale Antwort zu geben, muss man 
also erstmal wissen, wofür das ganze denn gebraucht wird.
In der gefragten Allgemeinheit (von beliebiger Stelle im Programm an 
beliebige andere Stelle springen) wäre tatsächlich setjmp/longjmp am 
ehesten passend. Allerdings wird das tatsächlich nur äußerst selten 
gebraucht. Selbst langjährige C-Programmierer setzen das extrem selten 
bis gar nie ein.

> Beantworte doch einfach die Frage.

Welches Auto ist das beste für mich? Details zu Anforderungen und 
Wünschen verrate ich nicht. Bitte beantworte "einfach" diese Frage…

F. F. schrieb:
> Wenn es sich aber um Programmierung von Mikrocontrollern handelt, sollte
> man so was tunlichst vermeiden.

Warum sollte das auf einem µC anders sein als auf dem PC?

GEKU schrieb:
> Wer weiss,  was bei einem Unterprogramm Aufruf passiert,  z.B Sichern
> von Register und PC, sowie die Funktion des Stack bei der Anlage lokaler
> Variablen, der kann auch sicher mit Goto umgehen.

Was haben die beiden denn miteinander zu tun? Register, Stack u.s.w sind 
Compiler-interne Implementationsdetails. goto ist ein Sprachkonstrukt, 
der vollkommen unabhängig davon definiert ist.

> Richtig, dass Goto nur eingesetzt werden, wenn andere Konstrukte
> scheitern oder das Programm unübersichtlich werden lassen.

Ja. Da gibt es wenige Anwendungsfälle, aber es gibt sie.

Maxim B. schrieb:
> GEKU schrieb:
>> Z.B. wenn man aus einer Schleife aussteigen muss,  ohne den Code nach
>> dem Schleifenkonstrukt zu exekutieren.
>
> "break" reicht nicht?

break überspringt nur den Code in der Schleife, nicht den danach.

NichtWichtig schrieb:
> Beantworte doch einfach die Frage.


Na dann:

1

printf("Programm beendet. Bitte neu starten\n");

2

exit(42);

Oliver

GEKU schrieb:
> sollten Gotos, die
> Labels außerhalb der eigenen Funktion anspringen tunlichst vermieden
> werden. Ausnahme Restart der Software.

Noch nicht mal dann. Zumindest wenn du mit Restart meinst "Sprung an den 
Anfang von main()". Denn der Stack wird auch dabei nicht aufgeräumt 
respektive initialisiert. Das passiert außerhalb von main() [1]

Jedes Mal, wenn man aus einer Funktion mit goto an den Anfang von main() 
springt, bleibt ein bißchen was auf dem Stack liegen. Mindestens die 
Rücksprungadresse; meist mehr, z.B. lokale Variablen der Funktion. Nach 
ein paar Zyklen (auf einem PC mit viel RAM ein paar Tausend Zyklen) 
läuft der Stack über und alles ist karpott.


[1] genauer gesagt passiert das bevor main() von der C 
Laufzeitumgebung aufgerufen wird. Genauso wie die Initialisierung des 
Datensegments.

Yalu X. schrieb:
> HGier mal ein kleines Beispiel,
> ...
> unter Verwendung des bereits vorgeschlagenen setjmp/longjmp:

Hier mal mit einer kleinen Ergänzung:

1

#include <stdio.h>

2

#include <setjmp.h>

3

#include <stdlib.h>

4

5

static jmp_buf env;

6

static int error = 1;

7

static int startwert = 0;

8

9

void sub2(void) {

10

  printf("sub2\n");

11

  if(error)

12

    longjmp(env, 1);

13

  printf("nie erreicht in sub2\n");

14

}

15

16

void sub1(void) {

17

  printf("sub1\n");

18

  sub2();

19

  printf("nie erreicht in sub1\n");

20

}

21

22

int main(void) {

23

  while(setjmp(env))

24

    printf("Neustart, startwert = %d\n", startwert++);

25

  printf("main\n");

26

  sub1();

27

  printf("nie erreicht in main\n");

28

}

Ausgabe:

main
sub1
sub2
Neustart, startwert = 0
main
sub1
sub2
Neustart, startwert = 1
main
sub1
sub2
Neustart, startwert = 2
main
sub1
sub2
Neustart, startwert = 3
main
sub1
sub2
Neustart, startwert = 4
main
sub1
sub2
Neustart, startwert = 5
main
sub1
sub2
Neustart, startwert = 6
main
sub1
sub2
Neustart, startwert = 7
main
sub1
sub2
Neustart, startwert = 8
main
sub1
sub2
Neustart, startwert = 9

;)

Oliver

leo schrieb:
> setjmp/longjmp

Es gibt gute Gründe, warum erfahrene Programmierer diese nicht 
einsetzen.
Gerade bei komplexen Programmen möchte man nur definierte Abläufe und 
kein wildes Umhergespringe. Sonst sieht man später selber nicht mehr 
durch, d.h. der Code wird fehleranfällig und schwer erweiterbar.

Ich habe es mal ausprobiert und man kann beim AVR sogar aus Interrupts 
heraus springen, aber ich hatte bisher keine Notwendigkeit, es auch 
praktisch einzusetzen. D.h. es hätte nichts vereinfacht oder verbessert.

Was dann alles letztendlich wieder zu der Frage an den (wie erwartet 
nach der Fragestellung verschollenen) TO führt: Warum?

Oliver

GEKU schrieb:
> Würde ich nicht machen, da man auch lokale Variable in einem Block {}
> generieren kann

Das ist nur eine Frage der Sichtbarkeit.
Denn in der Funktion darf sich der Stackpointer nicht ändern, sonst gibt 
es Probleme beim Variablenzugriff.

http://xyproblem.info/ ???

merciless

Bernd schrieb:
> Hat die üblichen Verdächtigen nicht gehindert den Thread vollzumachen.

Sommerloch.
Das dauert hier allerdings 12 Monate pro Jahr.

Rolf M. schrieb:
> break überspringt nur den Code in der Schleife, nicht den danach.

Man kann auch "return" benuzen. Dann ist man aus allen Schleifen dieser 
Funktion raus.

Peter D. schrieb:
> Ich habe es mal ausprobiert und man kann beim AVR sogar aus Interrupts
> heraus springen, aber ich hatte bisher keine Notwendigkeit, es auch
> praktisch einzusetzen. D.h. es hätte nichts vereinfacht oder verbessert.

Bin immer sehr an deinen Beiträgen hinsichtlich C interessiert.
Und sehr interessant, dass das geht.
Aber wie kommt man auf so eine Idee?
Den Interrupt soll man doch sowieso so schnell wie möglich verlassen (so 
empfiehlt es zumindest die Literatur, die ich gelesen habe) und 
außerhalb der ISR weiter verarbeiten.

Gibt es eigentlich ein Quasistandard für die Programmierung von 
Mikrocontroller?
Also wie Programme aufgebaut sein sollten und Literatur darüber?

Mach schrieb:
> Ich vermute mal nicht,
Mach schrieb:
> Nachtrag: Ich vermute doch.

Vermuten, raten, schätzen, und glauben ist bei solchen Fragestellungen 
definitiv nicht zielführend.

RTFM

Oliver

Oliver S. schrieb:
> Vermuten, raten, schätzen, und glauben ist bei solchen Fragestellungen
> definitiv nicht zielführend.

Es gibt doch so viele schöne Artikel, die alles ganz genau erklären.
Neu war für mich, daß nur einfache Vergleiche zulässig sind. Man darf 
also nicht setjmp() einer Variablen zuweisen.

F. F. schrieb:
> Aber wie kommt man auf so eine Idee?

Z.B. Du hast eine Schleife, wo es auf ganz genaues Timing ankommt und 
die an vielen verschiedenen Stellen hängen bleiben kann. Dann kannst Du 
vorher einen Timerinterrupt aufsetzen, der sie abbrechen kann, ohne 
ständig die Abbruchbedingung testen zu müssen.

Mach schrieb:
> Zumal es da auch um Compiler-Internas geht, wie wird der Stack
> aufgeraeumt.
> Und wenn das mittels longjmp geht, koennte der Compiler das auch fuer
> Goto erledigen. Also Spruenge ueber Funktionsgrenzen hinweg erlauben und
> trotzdem den Stack sauber halten.

Da es hier aber nicht um irgend eine hypothetische Programmiersprache, 
sondern ganz konkret um C geht, kommt es nicht drauf an, was alles sein 
könnte, sondern nur, was die Sprachdefinition dazu sagt. Compilerintenas 
haben damit nur so viel zu tun, als daß die Compiler den Sprachstandard 
zu implemetieren haben.

goto in C springt ohne jede sonstige Aktionen zum Sprungziel, und das 
schon seit Anbeginn der C-Zeitrechnung.

Oliver

GEKU schrieb:
> F. F. schrieb:
>> Also wie Programme aufgebaut sein sollten und Literatur darüber?
>
> Dieses Buch kann ich nur empfehlen.

Danke!

Goto als Vorwärtssprung innerhalb der gleichen Funktion ist durchaus 
legitim und habe ich auch häufiger gemacht, um wartbaren und lesbaren 
Code zu erhalten der mit allen anderen Konstrukten wie Kraut und Rüben 
aussah.

Zum Herausspringen aus mehreren verschachtelten Schleifen, ohne sich 
irgendwelche Abbruch-Variablen zu merken. Parserfunktionen sind solche 
Konstrukte, die bei einem Fehler möglichst schnell und zielgerichtet 
abbrechen sollen. Dort macht ein Vorwärtssprung aus der untersten 
Schleifenebene an das Ende der Funktion durchaus Sinn.

Goto ist per se kein schlechtes Konstrukt, es verleitet nur unerfahrene 
Programmierer es zu misbrauchen. Fakt ist aber auch, dass man auch ohne 
Goto Code schreiben kann, der genau die gleiche Funktionalität bietet. 
Ob der dann so sauber aussieht, steht auf einem anderen Blatt.

Viele Grüße!

Sven

Mach schrieb:
> Yalu X. schrieb:
>> Hier mal ein kleines Beispiel,
>> unter Verwendung des bereits vorgeschlagenen setjmp/longjmp:
>
> Wird der Stack in diesem Fall bereinigt?

Ja.

Peter D. schrieb:
> leo schrieb:
>> setjmp/longjmp
>
> Es gibt gute Gründe, warum erfahrene Programmierer diese nicht
> einsetzen.

Erfahrene Programmierer setzen setjmp/longjmp (wie auch goto) genau dort
ein, wo es sinnvoll ist :)

Peter D. schrieb:
> Neu war für mich, daß nur einfache Vergleiche zulässig sind. Man darf
> also nicht setjmp() einer Variablen zuweisen.

Das darf man schon. Es ist aber gängige Praxis, direkt nach dem Aufruf
von setjmp zu verzweigen, weswegen man sich eine zusätzliche Variable
sparen kann.

MaWin schrieb:
> Diese Analogie ist viel zu dumm!

Merke: Nicht alles, was du nicht verstehst, ist dumm.

Maxim B. schrieb:
> Rolf M. schrieb:
>> break überspringt nur den Code in der Schleife, nicht den danach.
>
> Man kann auch "return" benuzen. Dann ist man aus allen Schleifen dieser
> Funktion raus.

Dann ist man aber gleich komplett aus der Funktion raus. Außerdem hatten 
wir letztens erst eine Diskussion dazu, ob es guter Stil ist, kreuz und 
quer in der Funktion returns zu verteilen. Spätestens wenn du noch vor 
dem Verlassen irgendwas aufräumen musst, wird's unschön.

Mach schrieb:
> Mach schrieb:
>> (Ich vermute mal nicht
> Nachtrag: Ich vermute doch. Der Stackpointer kann ja bei setjmp einfach
> gesichert werden.

Genau deshalb gibt's ja setjmp.

Volle schrieb:
> als gute Gründe für die Verwendung von Goto gibt es:

Schon witzig, wie manche geradezu dazu indoktriniert wurden, goto blind 
zu hassen, statt das Ganze nüchtern und technisch zu betrachten und es 
einfach da (und nur da) zu nutzen, wo es nützlich ist - so wie man das 
mit anderen Sprachkonstrukten auch tut.

GEKU schrieb:
> Oliver S. schrieb:
>> goto in C springt ohne jede sonstige Aktionen zum Sprungziel, und das
>> schon seit Anbeginn der C-Zeitrechnung.
>
> Genau so ist es. Ums Stack muss sich der Programmierer kümmern..

Nein, um den kümmert sich der Compiler. Mit goto kann man die Funktion 
nicht verlassen, siehe

A. S. schrieb:
>> ↑ ↓ 3.6.6.1 The goto statement
>> Constraints
>> The identifier in a goto statement shall name a label located somewhere
>> in the current function.
>> Semantics
>> A goto statement causes an unconditional jump to the statement prefixed
>> by the named label in the current function.

hier wird ja viel phantasiert und im kreis gedreht ...
und unsinn zu setjmp/longjmp verbreitet.

setjmp/longjmp in c ist NICHT ein "goto" zu zielen ausserhalb einer 
aktiven funktion sondern ein GO BACK zu einem beliebigen sprungziel das 
vorher schon mal besucht wurde und mit setjmp markiert wurde!
setjmp speichert also den zustand  zum zeitpunkt des besuches/aufrufes 
und dieser wird später rekonstruiert, wenn dorthin zurückgesprungen 
wird.

UND goto ist ein nützlices kontrukt um z.b. eine eihheitliche 
fehlerbehandlung zu realisieren, auch in parsern wird goto oft verwendet 
oder zur laufzeitoptimiereung in echtzeitkritschen bereichen.


mt

Weil sich alles, was man mit goto machen konnte, auch mit anderen 
Konstrukten machen lässt.

1

switch(N) {

2

case 1:

3

  if(something) {

4

    case 2: return 0;

5

  }

6

default:

7

  return 1;

8

}

max schrieb:
> an kann hier keine simple Frage mehr stellen, ohne dass man gleich das
> ganze Projekt oder Vorhaben im Detail erlautert

Doch. Kann man.
Aber die Frage ist nicht simple, und sehr vermutlich auch nicht 
sinnvoll, schon gar nicht bei dem offensichtlichen Anfängerstatus des 
TO.

Und daher: Was genau an

http://xyproblem.info/

hast du nicht verstanden?

Oliver

Heiko L. schrieb:
> Weil sich alles, was man mit goto machen konnte, auch mit anderen
> Konstrukten machen lässt.

Es gibt vieles, das man durch andere Konstrukte ersetzen kann. Das heißt 
noch lange nicht, dass der Code dadurch gezwungenermaßen besser wird.

GEKU schrieb:
>> Auch ein goto  wäre möglich, solange man
>> die Programmebene nicht verlässt.
>
> Würde ich nicht machen, da man auch lokale Variable
> in einem Block {} generieren kann und diese von eine
> GOTO bei einem Sprung aus dem Block vermutlich nicht
> bereinigt werden.

Du vermutest falsch. Lerne bitte C.

GEKU schrieb:
>> goto in C springt ohne jede sonstige Aktionen zum Sprungziel,
>> und das schon seit Anbeginn der C-Zeitrechnung.
>
> Genau so ist es. Ums Stack muss sich der Programmierer kümmern..

Das ist falsch[*]. Man kann nicht mit "goto" aus einer Funktion 
herausspringen[*]. Lerne bitte C.

[*] Ausnahme: computed goto, aber das ist eine GCC-Erweiterung.

Bei der ganzen Diskussion um "goto" habe ich mir überlegt, ob es einen 
Grund geben könnte ganz aus dem Programmablauf auf einem Mikrocontroller 
aus zu steigen, sodass er wirklich nichts mehr macht.
Hat schon einmal jemand so was gemacht und gäbe es relevante Gründe 
(Sicherheitsabbruch) das zu tun?

Ja klar, so würde ich es machen.
Mir kam da halt der Gedanke an einen Notfallausstieg.
Aber auch da gibt es andere Wege.

F. F. schrieb:
> Bei der ganzen Diskussion um "goto" habe ich mir überlegt, ob es einen
> Grund geben könnte ganz aus dem Programmablauf auf einem Mikrocontroller
> aus zu steigen, sodass er wirklich nichts mehr macht.

In der Tuningszene gibt es Geräte um das Motorsteuergerät zu tunen. 
Damit nun nicht jemand sein Gerät nach getaner Arbeit weiter verkauft, 
führt dieses als letztes Kommando ein Full-Erase durch. Danach rennt die 
CPU nur noch durch den gelöschten Flash und führt 0xFF aus.

Stefanus F. schrieb:
> F. F. schrieb:
>> ob es einen
>> Grund geben könnte ganz aus dem Programmablauf auf einem Mikrocontroller
>> aus zu steigen, sodass er wirklich nichts mehr macht.
>
> Wo willst du denn hin springen, ins Nirvana?

In die wirkliche Welt natürlich. Wie am Ende von 13th Floor.

GEKU schrieb:
> Zu Empfehlen

Jau!
Danke!

Feststeller schrieb:
> S. R. schrieb:
>
>> Du vermutest falsch. Lerne bitte C.
>
> Warum bittest Du ihn, das zu tun?

Weil es keinen Sinn hat, in so einer Diskussion mit Vermutungen und 
Spekulationen um sich zu werfen.

F. F. schrieb:
> Bei der ganzen Diskussion um "goto" habe ich mir überlegt, ob es einen
> Grund geben könnte ganz aus dem Programmablauf auf einem Mikrocontroller
> aus zu steigen, sodass er wirklich nichts mehr macht.
> Hat schon einmal jemand so was gemacht und gäbe es relevante Gründe
> (Sicherheitsabbruch) das zu tun?

Kann z.B. vorkommen, wenn ein schwerwiegender Fehler aufgetreten ist. 
Dann springt man in eine Routine, die hoffentlich noch irgendeine 
Meldung rausbekommt und dann in eine Endlosschleife geht, bis der 
Watchdog dann automatisch den ganzen Prozessor neu startet.

Arduino Fanboy D. schrieb:
> Ja!
>
> Dafür wurde exit() erfunden.

Um µCs ins Nirvana zu schicken? Eher nicht.

Arduino Fanboy D. schrieb:
> Aber immerhin sind das µC !

Ich hab nicht behauptet, dass man es auf µCs nicht einsetzen kann, 
sondern lediglich der Behauptung widersprochen, dass es dafür gemacht 
sei.

Michael K. schrieb:
> Toll wenn man nur diese eine MCU kennt.

Die MCU ist doch völlig egal. Wenn es eine lib gibt, die eine Funktion 
exit enthält, sollte auch dokumentiert sein, was die macht. Ob man die 
dann sinnvoll verwenden kann, bleibt dem geneigten Programmierer 
überlassen.

Oliver

Oliver S. schrieb:
> Michael K. schrieb:
>> Toll wenn man nur diese eine MCU kennt.
>
> Die MCU ist doch völlig egal. Wenn es eine lib gibt, die eine Funktion
> exit enthält, sollte auch dokumentiert sein, was die macht.

Wenn ich in eine Endlosschleife rennen will, kann ich auch einfach eine 
Endlosschleife hinschreiben, statt erst in der Doku nachzuschauen, ob 
bei der verwendeten libc exit() das zufällig auch tut.

GEKU schrieb:
> GEKU schrieb:
>> Auch ein goto  wäre möglich, solange man die Programmebene nicht
>> verlässt.
>
> Würde ich nicht machen, da man auch lokale Variable in einem Block {}
> generieren kann und diese von eine  GOTO bei einem Sprung aus dem Block
> vermutlich nicht bereinigt werden.

Mit der Betonung auf "vermutlich".

Hier ein Beispiel, wie eine Bereinigung stattfindet:

1

void f (char*);

2

3

char func (char a, unsigned char b)

4

{

5

    if (a < 'P')

6

    {

7

        char c[b];

8

        f (c);

9

        if (a < 'M')

10

            goto end;

11

        f (c);

12

    }

13

    a++;

14

end:

15

    return a;

16

}

Abhängig von a wird Array c[] initialisiert, dessen Größe erst zur 
Laufzeit bekannt ist. f() dient nur der Verwendung von c[].  Je nach a 
wird der Block vorzeitig verlassen und ans Ende der Funktion gesprungen, 
und c[] wird danach im Block noch 1x verwendet, kann also nicht vor dem 
goto aufgeräumt werden.

Code (avr-gcc):

c[] wird in Zeile :12 auf den Stack angelegt, der Wert von SP wird in 
R14/15 gemerkt (Zeilennummern siehe asm-Kommentar).

Nach dem goto-Vergleich in :14 wird in beiden Pfaden SP wieder aus 
R14/15 hergestellt.

1

func:

2

  push r12

3

  push r13

4

  push r14

5

  push r15

6

  push r17

7

/* prologue: function */

8

  mov r17,r24   ;  a, a

9

 ;  foo.c:21: }

10

  in r14,__SP_L__   ;  tmp55

11

  in r15,__SP_H__   ;  tmp55

12

 ;  foo.c:10:     if (a < 'P')

13

  cpi r24,lo8(80)   ;  a,

14

  brge .L2

15

 ;  foo.c:12:         char c[b];

16

  in r24,__SP_L__

17

  in r25,__SP_H__

18

  sub r24,r22   ; , b

19

  sbc r25,__zero_reg__

20

  out __SP_L__,r24

21

  out __SP_H__,r25

22

  adiw r24,1

23

  movw r12,r24   ;  tmp52,

24

 ;  foo.c:13:         f (c);

25

  call f

26

 ;  foo.c:14:         if (a < 'M')

27

  cpi r17,lo8(77)   ;  a,

28

  brge .L3

29

  out __SP_L__,r14   ;  tmp55

30

  out __SP_H__,r15   ;  tmp55

31

.L4:

32

 ;  foo.c:21: }

33

  mov r24,r17   ; , a

34

/* epilogue start */

35

  pop r17

36

  pop r15

37

  pop r14

38

  pop r13

39

  pop r12

40

  ret  

41

.L3:

42

 ;  foo.c:16:         f (c);

43

  movw r24,r12   ; , tmp52

44

  call f

45

  out __SP_L__,r14   ;  tmp55

46

  out __SP_H__,r15   ;  tmp55

47

.L2:

48

 ;  foo.c:18:     a++;

49

  subi r17,lo8(-(1))   ;  a,

50

  rjmp .L4