Apakah saya memahami tumpukannya? tolong perbaiki saya

Saya memiliki kode ini yang ditulis dalam c:

int main(){
  double x, y;
  int a, b, c;
  int *p;

dan saya punya:

sizeof(int)=4
sizeof(double)=8

Apakah struktur memorinya seperti ini? Lebih detail dalam mode grafis:

IN MEMORY:(whole memory)
  LE = Little Endian  (INTEL)
  BE = Big Endian     (MIPS)

                                                  ------------------
                                    0x00000000   |                  | ?
                                                  ------------------
                                         .                 .
                                         .                 .
                                         .                 .
                                                  ------------------
                                    0x0012ff60   |  64(LE)  00(BE)  | 
                                                  ------------------
                                                  ------------------
                                    0x0012ff61   |  ff(LE)  12(BE)  | 
                                                  ------------------
                                                  ------------------
                                    0x0012ff62   |  12(LE)  ff(BE)  | 
                                                  ------------------
                                                  ------------------
                                    0x0012ff63   |  00(LE)  64(BE)  | 
                                                  ------------------

                                                  ------------------
                                    0x0012ff64   | 00(LE)   00(BE)  |  c         if c = 256        (base10)
                                                  ------------------                c = 0x00000100 (base16)
                                                  ------------------
                                    0x0012ff65   | 01(LE)   00(BE)  |  c   0x0012ff64 points to c variable
                                                  ------------------       0x0012ff64 is a pointer
                                                  ------------------
                                    0x0012ff66   | 00(LE)   01(BE)  |  c
                                                  ------------------
                                                  ------------------
                                    0x0012ff67   | 00(LE)   00(BE)  |  c 
                                                  ------------------
                                                  ------------------
                                    0x0012ff68   |                  |  b
                                                  ------------------
                                                           .
                                                           .
                                                           .
                                                  ------------------
                                    0x0012ff6c   |                  |  a
                                                  ------------------
                                                           .
                                                           .
                                                           .
                                                  ------------------
                                    0x0012ff70   |                  |  y
                                                  ------------------
                                                  ------------------
                                    0x0012ff71   |                  |  y
                                                  ------------------  
                                                  ------------------
                                    0x0012ff72   |                  |  y
                                                  ------------------
                                                  ------------------
                                    0x0012ff73   |                  |  y
                                                  ------------------
                                                  ------------------
                                    0x0012ff74   |                  |  y
                                                  ------------------
                                                  ------------------
                                    0x0012ff75   |                  |  y
                                                  ------------------
                                                  ------------------
                                    0x0012ff76   |                  |  y
                                                  ------------------
                                                  ------------------
                                    0x0012ff77   |                  |  y
                                                  ------------------
                                                          .
                                                          .
                                                          .
                                                  ------------------
                                    0x0012ff78   |                  |  x
                                                  ------------------
                                                          .
                                                          .
                                                          .
                                                  ------------------
                                    0xfffffffff  |                  |  ?
                                                  ------------------

Pertanyaan saya: saat kita memasukkan sth ke dalam tumpukan, apakah kita melakukan ini? masukkan deskripsi gambar di sini

1) Maksud saya, kita mendorong data di akhir tumpukan dengan nilai alamat yang lebih tinggi?

2) atau kita mendorong data di tumpukan teratas dengan nilai alamat yang lebih rendah?

3) berapa banyak alamat memori yang diambil setiap tumpukan? Tergantung pada apa?

Terima kasih


stack variables x86 memory assembly
person MLSC    schedule 18.02.2014    source sumber
comment
Register pasang surut tidak menunjuk ke penunjuk instruksi pengembalian melainkan ke ebp fungsi sebelumnya   -  person BlackBear    schedule 18.02.2014
comment
Jangan lupa bahwa kompiler dapat (dan mungkin akan) menyimpan variabel lokal dalam register - beberapa atau semuanya mungkin tidak ada di tumpukan sama sekali.   -  person Brendan    schedule 18.02.2014
comment
Perhatikan bahwa arti dari register EBP mungkin bergantung pada kompiler: Saat menggunakan optimasi, EBP bahkan mungkin tidak digunakan sama sekali. Namun dalam kebanyakan kasus, tumpukan pada mesin x86 berfungsi seperti yang Anda pahami. Namun di x86 semua datanya adalah little endian!   -  person Martin Rosenau    schedule 18.02.2014

Jawaban (1)


arrow_upward
3
arrow_downward

Pada mesin x86, jika kompiler tidak melakukan sesuatu yang luar biasa, tumpukan akan bertambah ke bawah. Pada push penunjuk tumpukan akan berkurang berdasarkan ukuran push, dan data pushed akan masuk ke alamat tumpukan yang lebih rendah.

Pada pop, penunjuk tumpukan akan bertambah sesuai dengan ukuran pop.

Saya tidak mengomentari MIPS, meskipun Anda menyebutkannya dalam pertanyaan Anda, karena:

  1. Saya tidak tahu apa-apa tentang arsitektur MIPS
  2. pertanyaan Anda diberi tag x86.

Mengenai ukuran setiap variabel di tumpukan, itu 100% bergantung pada kompiler, jadi saya tidak bisa mengomentarinya.

person Nathan Fellman    schedule 18.02.2014
comment
Oke, saya tidak peduli MIPS sungguh, apakah saya menulis struktur memori untuk INTEL dengan benar? Saya memiliki 3 pertanyaan di posting saya dan saya akan berterima kasih jika Anda menjawab lebih detail :) - person MLSC; 18.02.2014
comment
Dia juga bertanya tentang ukuran (total) (menurut saya). Ini dipilih oleh kompiler (dan seringkali dibatasi oleh sistem operasi). Di gcc Anda dapat mengubahnya dengan opsi --stack. Nilai tipikal pada mesin modern adalah 1 MB; Linux modern sering kali memiliki batas 10 MB (ulimit -s). - person TypeIA; 18.02.2014
comment
@MortezaLSC: Kelihatannya cukup oke. Perhatikan juga bahwa Anda menanyakan dua pertanyaan, karena (1) dan (2) merupakan kebalikan satu sama lain. - person Nathan Fellman; 18.02.2014
comment
@ Nathan Fellman Jadi ini tidak penting di bagian atas atau akhir tumpukan..intinya the pushed data will go onto the lower addresses of the stack. Kanan? - person MLSC; 18.02.2014
comment
Dalam pemahaman saya tentang memori, saya menunjukkan alamat dari 0x00000000 di atas hingga 0xfffffffff di bawah..tetapi gambarnya berbeda...ya? :( - person MLSC; 18.02.2014
comment
@MortezaLSC: alamat sebenarnya bergantung pada nilai register Stack Segment (SS) dan nilai awal Stack Pointer (ESP). Secara umum, Anda tidak disarankan untuk membuat asumsi mengenai nilai-nilai ini. - person Nathan Fellman; 18.02.2014