From: space@ncc1701.stgt.sub.org (Lars Soltau)
Newsgroups: de.comp.gnu,de.comp.lang.c
Subject: Re: was macht alloca?
Date: 13 Sep 92 09:55:56 GMT
Organization: United Federation of Planets
Distribution: world
	<920829440@monad.swb.de> <SPACE.92Aug31103804@ncc1701.stgt.sub.org>
	<1992Sep01.065949.23504@rubikon.han.de> <5180@reto.stgt.sub.org>
	<SPACE.92Sep3110721@ncc1701.stgt.sub.org> <A2nyHG@ppcger.ppc.sub.org>
NNTP-Posting-Host: ncc1701.stgt.sub.org
In-reply-to: Sepp@ppcger.ppc.sub.org's message of 9 Sep 92 16:26:42 GMT

>>>>> On 9 Sep 92 16:26:42 GMT, Sepp@ppcger.ppc.sub.org (Josef Wolf) said:

> In <SPACE.92Sep3110721@ncc1701.stgt.sub.org> space@ncc1701.stgt.sub.org (Lars Soltau) writes:
> ] >>>>> On 2 Sep 92 18:25:55 GMT, hcz@reto.stgt.sub.org (Heike C Zimmerer) said:
> ] > So bescheuert finde ich das nicht. Das Anlegen/Loeschen kostet nicht viel
> ] > Assemblerinstruktionen (hier ists genau eine (1)).
> ] Das ist auch nicht der Grund. Es wird nur kompliziert fuer den Compiler,
> ] wenn mit break, continue oder goto aus dem Block oder in den Block gesprungen
>                                 ^^^^
> (igitt :-) (nein, bitte kein flame-war :-)

Ha, da will mir jemand mein Goto vermiesen. Auch einer von den
Muesli-Programmierern, die lieber zehn Flags einfuehren als ein Goto? :-)

> ] > Neben dem Scope gibt es aber noch einen wichtigen Grund, Variable
> ] > in einem lokalen Block zu definieren: Speicherplatz.
> ] 
> ] Das kann man aber auch anders loesen. Es ist naemlich viel einfacher,
> ] festzustellen, welche Bloecke sich gegenseitig nie aufrufen. Damit koennen
> ] dann die lokalen Variablen dieser Bloecke ueberlappend auf dem Stack
> ] angeordnet werden.

> Genau darum geht es ja auch. Dazu muss aber erst einmal bekannt sein,
> welche Variablen in welchen Bloecken auch wirklich verwendet werden.
> Darum macht es ja auch Sinn, Variablen innerhalb eines Blockes zu
> definieren.

Latuernich, das hab ich doch nicht bestritten. Ich meinte nur, dass deswegen
trotzdem alle Variablen beim Eintritt in die Funktion angelegt werden und beim
Austritt wieder zerstoert, d.h. der Stackpointer wird wirklich nur beim
Eintritt und Austritt in die/aus der Funktion manipuliert.

Beispiel:

foo() {
  /* block 1 */
  {
    char nase[100];

    nase[0] = '\0';
  }
  /* block 2 */
  {
    int baer[100];

    baer[0] = 0;
  }
}

Was ein intelligenter Compiler daraus macht, ist etwa folgendes:

_foo:
  link a5,400		; 400 bytes fuer lokale variablen bereitstellen
; block 1
  move.b #0,(a7)	; letztes byte des stacks wird als nase[0] gesehen
; block 2
  move.l #0,(a7)	; letztes langwort des stacks wird als baer[0] gesehen
; funktionsende
  unlk a5

Das heisst, es wird beim Eintritt in die Funktion so viel Stack reserviert, um
alle lokalen Variablen aufzunehmen, wobei Variablen aus verschiedenen Bloecken
ueberlappend angeordnet werden, wenn diese Bloecke sich nicht gegenseitig
aufrufen. Ergebnis: im Durchschnitt nicht mehr Speicher verbraten, und man
muss sich nicht soviele Gedanken machen, ob aus einem Block rausgesprungen
oder hineingesprungen wird.
--
Lars Soltau	bang: <insert ridiculously long path>	    BIX: -- no bucks --
		smart: space@ncc1701.stgt.sub.org

     Germany, Stuttgart-Zuffenhausen, where dreams come true: Heaven is 911!
Newsgroups: de.comp.gnu