Nicht angemeldet. · Kennwort vergessen · Registrieren

andi91
Mitglied seit 11/2011
36 Beiträge
Betreff: Klausur Juli 2010 & 2009
Ich hätte noch 2 Fragen.....

Bei der Klausur von Juli 2010, die 3c):

Gegeben sei folgendes Programmfragment:

union {
             struct {uint8_t reg_lo, reg_hi;};
             uint16_t reg16;
         } reg;

Wieviel Speicher (in Bytes) wird durch die Variable reg belegt? Skizzieren Sie
außerdem, wie die einzelnen Komponenten von reg im Speicher abgelegt werden.


Mein Ansatz wäre: Bei unions wird ja immer so viel Speicher  benötigt, wie das größte Element innerhalb dieser braucht, und das ist uint16_t reg16....
 uint16_t:   0--> 2^16 -1  
1 byte sind 8bit = 2^3 bit dh 2^16/2^3 = 2^13 Byte -1  werden benötigt oder wie ist das gemeint??

Abgelegt werden die Elemente ja übereinander also würde ich es so skizzieren:
Erst kommt das Struct, dann reg 16:
                                                            .struct     reg_lo       reg_hi
                                             reg---->
                                                            .reg16
Also analog zu Folie 14-21 im Skript... Stimmt das soweit?
Danke!!
Steppenwolf
GSPiC-Übungsleiter
Mitglied seit 05/2011
31 Beiträge
Hi,

Zitat von andi91:
Mein Ansatz wäre: Bei unions wird ja immer so viel Speicher  benötigt, wie das größte Element innerhalb dieser braucht, und das ist uint16_t reg16....

genau. Also braucht reg 16 Bits bzw. 2 Bytes. Deine folgende Rechnung...

uint16_t:   0--> 2^16 -1  
1 byte sind 8bit = 2^3 bit dh 2^16/2^3 = 2^13 Byte -1  werden benötigt oder wie ist das gemeint??

... verstehe ich deswegen nicht.

Erst kommt das Struct, dann reg 16:
                                                            .struct     reg_lo       reg_hi
                                             reg---->
                                                            .reg16
Also analog zu Folie 14-21 im Skript... Stimmt das soweit?
Danke!!

Das ist richtig.
andi91
Mitglied seit 11/2011
36 Beiträge
    Zitat von andi91:
    Mein Ansatz wäre: Bei unions wird ja immer so viel Speicher  benötigt, wie das größte Element innerhalb dieser braucht, und das ist uint16_t reg16....


genau. Also braucht reg 16 Bits bzw. 2 Bytes. Deine folgende Rechnung...

    uint16_t:   0--> 2^16 -1 
    1 byte sind 8bit = 2^3 bit dh 2^16/2^3 = 2^13 Byte -1  werden benötigt oder wie ist das gemeint??


... verstehe ich deswegen nicht.

Okay, da hab ich was durcheinandergehaun, ich hab den Wertebereich angegeben und das vermischt mit dem Speicherbedarf^^


                                                            .struct     reg_lo       reg_hi
                                             reg---->
                                                            .reg16

Sind reg_lo und reg_hi dann in einem Behälter und müsste nicht dann die Adresse davon dastehen, also &reg_lo usw? Wieso steht dann bei .reg16 nichts?

Danke!!
Steppenwolf
GSPiC-Übungsleiter
Mitglied seit 05/2011
31 Beiträge
Zitat von andi91:
                                                            .struct     reg_lo       reg_hi
                                             reg---->
                                                            .reg16

Sind reg_lo und reg_hi dann in einem Behälter und müsste nicht dann die Adresse davon dastehen, also &reg_lo usw? Wieso steht dann bei .reg16 nichts?

Häh, die Lösung ist doch von *dir*; warum fragst du *mich* Fragen zu *deiner* Lösung :)? Warum hast *du* das denn so hingeschrieben bzw. nicht hingeschrieben?
andi91
Mitglied seit 11/2011
36 Beiträge
Weil ich mir nicht sicher bin bei der Lösung^^
In den Folien stehen in den Behältern i-wie Adressen drinnen oder versteh ich das falsch? ^^
andi91
Mitglied seit 11/2011
36 Beiträge
Ich hätte noch eine Frage zu
Juli 2009 3b)
Die Fragestellung:
Wie wird die Parameterübergabe über den Stack (z. B. auf einer Intel-Prozessorarchitektur)
realisiert. Beschreiben Sie, wie die aktuellen Parameter abgelegt werden
und wie der Zugriff über die formalen Parameter erfolgt (ggf. durch Skizze
veranschaulichen!)

Ich wollte nur fragen, ob es hier ausreicht zu skizzieren, wie ein Stack aussieht von der Reihenfolge der Paramter/lok. Variablen her analog zu den Folien.
Ganz versteh ich die Frage aber nicht, weil in den Folien wird nur beschrieben, wie die Var. & Parmater samt Rücksprungadressen usw abgelegt werden dh in welcher Reihenfolge, aber wie wird eigentlich auf die form. Parameter zugegriffen?
Danke!
sicherha
Informatik-Veteran
Mitglied seit 10/2010
53 Beiträge
Zuerst am besten eine kurze Wiederholung der Definition, was die Begriffe formale Parameter und "aktuelle" Parameter [1] zu bedeuten haben:
  • Formale Parameter sind die Namen, unter denen die aufgerufene Funktion auf ihre Parameter zugreifen kann.
  • "Aktuelle" Parameter sind die tatsächlichen Werte, die der Aufrufer an die aufgerufene Funktion übergibt.

So schaut nun der Stack aus, wenn man eine Funktion aufruft, die drei Argumente [2] entgegennimmt:

|        ...        |
|    Argument 2     |
|    Argument 1     |
|    Argument 0     |
| Rücksprungadresse | <- Stack-Zeiger
+-------------------+

Der Stack wächst von oben nach unten, der Stack-Zeiger zeigt immer auf das letzte gültige Element.
Der Aufrufer legt zuerst die "aktuellen" Parameter in umgekehrter Reihenfolge und anschließend die Rücksprungadresse auf den Stack. Das Programm springt in die aufgerufene Funktion. Diese kann nun mittels Zeigerarithmetik auf ihre formalen Parameter zugreifen:
  • Argument 0 liegt an Adresse (Stack-Zeiger + 4)
  • Argument 1 liegt an Adresse (Stack-Zeiger + 8)
  • Argument 2 liegt an Adresse (Stack-Zeiger + 12)
  • usw.

Ein Problem an diesem Modell ist, dass man innerhalb der Funktion den Stack nicht beliebig dynamisch wachsen lassen kann, weil sich dadurch der Stack-Zeiger verschieben würde und damit die Adressen für die formalen Argumente nicht mehr gültig wären. Deswegen findet man oft dieses erweiterte Modell:

|         ...         |
|     Argument 2      |
|     Argument 1      |
|     Argument 0      |
|  Rücksprungadresse  |
| alter Frame-Pointer | <- Frame-Pointer, Stack-Pointer
+---------------------+

Der Frame-Pointer ist ein zusätzliches CPU-Register, das immer auf den Beginn des Stack-Frames der aktuellen Funktion zeigt. Beim Betreten einer Funktion wird als Allererstes der alte Frame-Pointer auf den Stack gelegt und der neue Frame-Pointer auf den Beginn des neuen Stack-Frames gesetzt. Unmittelbar vor dem Rücksprung aus der Funktion wird der alte Frame-Pointer wiederhergestellt.

Was bringt uns das? - Jetzt können wir innerhalb der Funktion den Stack-Zeiger nach Herzenslust in der Gegend rumschieben, aber können trotzdem noch problemlos auf unsere formalen Parameter zugreifen, indem wir ihre Adressen relativ zum Frame-Pointer berechnen:
  • Argument 0 liegt an Adresse (Frame-Pointer + 8)
  • Argument 1 liegt an Adresse (Frame-Pointer + 12)
  • Argument 2 liegt an Adresse (Frame-Pointer + 16)
  • usw.

[1] Aktuell ist eine Fehlübersetzung des englischen actual - korrekt müsste es tatsächliche Parameter heißen. Leider hat sich der falsche Begriff mittlerweile eingebürgert. :-(
[2] Die Begriffe Argument und Parameter sind in diesem Kontext synonym.
Dieser Beitrag wurde 2 mal verändert, zuletzt am 27.03.2012, 17:27 von sicherha.
Schließen Kleiner – Größer + Auf diesen Beitrag antworten:
Prüfcode: VeriCode Gib bitte das Wort aus dem Bild ins folgende Textfeld ein. (Nur die Buchstaben eingeben, Kleinschreibung ist in Ordnung.)
Smileys: :-) ;-) :-D :-p :blush: :cool: :rolleyes: :huh: :-/ <_< :-( :'( :#: :scared: 8-( :nuts: :-O :troll:
Weitere Zeichen:
Gehe zu Forum
Powered by the Unclassified NewsBoard software, 20110527-dev, © 2003-8 by Yves Goergen