Not logged in. · Lost password · Register

andi91
Member since Nov 2011
36 posts
Subject: 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
Member since May 2011
31 posts
Hi,

Quote by 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
Member since Nov 2011
36 posts
    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
Member since May 2011
31 posts
Quote by 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
Member since Nov 2011
36 posts
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
Member since Nov 2011
36 posts
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
Member since Oct 2010
53 posts
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.
This post was edited 2 times, last on 2012-03-27, 17:27 by sicherha.
Close Smaller – Larger + Reply to this post:
Verification code: VeriCode Please enter the word from the image into the text field below. (Type the letters only, lower case is okay.)
Smileys: :-) ;-) :-D :-p :blush: :cool: :rolleyes: :huh: :-/ <_< :-( :'( :#: :scared: 8-( :nuts: :-O :troll:
Special characters:
Go to forum
Powered by the Unclassified NewsBoard software, 20110527-dev, © 2003-8 by Yves Goergen