Temel işaretçi ve yığın işaretçisi tam olarak nedir? Neye işaret ediyorlar?

DrawSquare () 'in DrawLine () öğesini çağırdığı wikipedia'dan gelen bu örneği kullanarak ,

(Bu şemada altta yüksek adresler ve üstte düşük adresler bulunduğunu unutmayın.)

Kimse bana açıklayabilir neyi Could ebpve espbu bağlamda nelerdir?

Gördüğüm kadarıyla, yığın işaretçisinin her zaman yığının üstünü ve temel işaretçiyi geçerli işlevin başlangıcını gösterdiğini söyleyebilirim? Ya da ne?

edit: Bu Windows programları bağlamında demek

edit2: Ve nasıl da eipçalışır?

edit3: MSVC ++ aşağıdaki kodu var:

var_C= dword ptr -0Ch
var_8= dword ptr -8
var_4= dword ptr -4
hInstance= dword ptr  8
hPrevInstance= dword ptr  0Ch
lpCmdLine= dword ptr  10h
nShowCmd= dword ptr  14h

Hepsi dwords gibi görünüyor, böylece her biri 4 bayt alıyor. Böylece, 4 baytlık var_4 değerine kadar bir boşluk olduğunu görebiliyorum. Onlar neler? Wikipedia'nın resminde görülebileceği gibi, bunun dönüş adresi olduğunu varsayıyorum?

(Editörün notu: Michael'ın cevabından uzun bir alıntı kaldırıldı, bu soruya ait değil, ancak bir takip sorusu düzenlendi):

Bunun nedeni, işlev çağrısının akışının:

* Push parameters (hInstance, etc.)
* Call function, which pushes return address
* Push ebp
* Allocate space for locals

Benim sorum (son, umarım!) Şimdi, tam olarak prolog sonuna kadar çağırmak istediğiniz işlevin argümanlarını pop an ne olur? Ebp, esp'nin o anlarda nasıl geliştiğini bilmek istiyorum (Prologun nasıl çalıştığını zaten anladım, sadece yığındaki ve prologdan önce argümanları ittikten sonra ne olduğunu bilmek istiyorum).

esp dediğiniz gibi, yığının en üstünde.

ebpgenellikle espişlevin başlangıcında olarak ayarlanır . Fonksiyon parametrelerine ve yerel değişkenlere sırasıyla sabit bir ofset ekleyerek ve çıkararak erişilir ebp. Tüm x86 çağrı kuralları ebp, işlev çağrıları arasında korunuyor olarak tanımlanır . ebpkendisi aslında bir hata ayıklayıcıda yığın yürüyüş ve diğer çerçeveler yerel değişkenleri çalışmak için görüntüleme sağlayan önceki karenin temel işaretçisini işaret eder.

Çoğu işlev prologları şuna benzer:

push ebp      ; Preserve current frame pointer
mov ebp, esp  ; Create new frame pointer pointing to current stack top
sub esp, 20   ; allocate 20 bytes worth of locals on stack.

Daha sonra fonksiyonda kodunuz olabilir (her iki yerel değişkenin 4 bayt olduğunu varsayarsak)

mov [ebp-4], eax    ; Store eax in first local
mov ebx, [ebp - 8]  ; Load ebx from second local

Etkinleştirebileceğiniz FPO veya kare işaretçisi ihmal optimizasyonu bunu gerçekten ortadan kaldıracak ve ebpbaşka bir kayıt olarak kullanacak ve yerel halktan doğrudan erişebilecektir esp, ancak hata ayıklayıcı daha önceki işlev çağrılarının yığın çerçevelerine doğrudan erişemediğinden bu hata ayıklamayı biraz daha zorlaştırır.

DÜZENLE:

Güncellenmiş sorunuz için, yığındaki eksik iki giriş:

var_C = dword ptr -0Ch
var_8 = dword ptr -8
var_4 = dword ptr -4
*savedFramePointer = dword ptr 0*
*return address = dword ptr 4*
hInstance = dword ptr  8h
PrevInstance = dword ptr  0C
hlpCmdLine = dword ptr  10h
nShowCmd = dword ptr  14h

Bunun nedeni, işlev çağrısının akışının:

• Push parametreleri ( hInstancevb.)
• Dönüş adresini iten çağrı fonksiyonu
• it ebp
• Yerliler için yer ayırın

ESP, yığının üzerine bir kelime veya adres itildiğinde veya atıldığında değişecek olan geçerli yığın işaretçisidir. EBP, derleyicinin ESP'yi doğrudan kullanmaktan ziyade bir işlevin parametrelerini ve yerel değişkenlerini takip etmesinin daha kolay bir yoludur.

Genel olarak (ve bu derleyiciden derleyiciye değişebilir), çağrılan bir işleve ilişkin tüm bağımsız değişkenler çağrı işlevi tarafından yığına iletilir (genellikle işlev prototipinde bildirildikleri ters sırada, ancak bu değişir) . Daha sonra işlev çağrılır, bu da dönüş adresini (EIP) yığına iter.

Fonksiyona girişte, eski EBP değeri istif üzerine itilir ve EBP ESP değerine ayarlanır. Daha sonra ESP, işlevin yerel değişkenleri ve geçici aralıkları için alan ayırmak üzere azaltılır (yığın bellekte aşağı doğru büyüdüğü için). Bu noktadan sonra, işlevin yürütülmesi sırasında, işleve ilişkin argümanlar istif üzerinde EBP'den pozitif ofsetlerde bulunur (çünkü işlev çağrısından önce itildikleri için) ve yerel değişkenler EBP'den negatif ofsetlerde bulunur (çünkü fonksiyon girişinden sonra yığına tahsis edilmişlerdir). Bu nedenle EBP'ye çerçeve işaretçisi denir , çünkü işlev çağrısı çerçevesinin ortasını gösterir .

Çıkıştan sonra, tüm işlevin yapılması gereken ESP'yi EBP değerine ayarlamak (yerel değişkenleri yığından ayırır ve yığının üstündeki EBP girişini ortaya çıkarır), ardından eski EBP değerini yığından çıkarır, ve sonra işlev geri döner (dönüş adresini EIP'ye atmak).

Çağıran işleve geri döndükten sonra, diğer işlevi çağırmadan hemen önce yığına aktardığı işlev bağımsız değişkenlerini kaldırmak için ESP'yi artırabilir. Bu noktada, yığın, çağrılan işlevi çağırmadan önceki durumundadır.

Haklısın. Yığın işaretçisi yığında üst öğeyi ve temel işaretçi işlev çağrılmadan önce yığının "önceki" üstünü işaret eder .

Bir işlevi çağırdığınızda, herhangi bir yerel değişken yığın üzerinde saklanır ve yığın işaretçisi artırılır. İşlevden döndüğünüzde, yığındaki tüm yerel değişkenler kapsam dışına çıkar. Bunu, yığın işaretçisini temel işaretçiye (işlev çağrısından önceki "önceki" üst) geri ayarlayarak yaparsınız.

Bellek tahsisini bu şekilde yapmak çok , çok hızlı ve etkilidir.

DÜZENLEME: Daha iyi bir açıklama için bkz x86 Demontajı / Fonksiyonlar ve Stack Çerçeveler montaj x86 hakkında kitabu içinde. Visual Studio kullanarak ilginizi çekebilecek bazı bilgiler eklemeye çalışıyorum.

Arayan EBP'sinin ilk yerel değişken olarak depolanmasına standart yığın çerçevesi denir ve bu, Windows'daki neredeyse tüm çağrı kuralları için kullanılabilir. Arayan veya arayanın iletilen parametreleri ayırıp ayırmadığı ve kayıtlarda hangi parametrelerin geçirildiği farklar vardır, ancak bunlar standart yığın çerçevesi sorununa diktir.

Windows programlarından bahsetmişken, muhtemelen C ++ kodunuzu derlemek için Visual Studio kullanabilirsiniz. Microsoft'un, dbghlp kitaplığını ve yürütülebilir dosya için PDB dosyasını kullanmadan yığını yürümeyi neredeyse imkansız kılan Frame Pointer Omission adlı bir optimizasyon kullandığını unutmayın.

Bu Çerçeve İşaretçisi Atlama, derleyicinin eski EBP'yi standart bir yerde saklamadığı ve EBP kaydını başka bir şey için kullanmadığı anlamına gelir, bu nedenle yerel değişkenlerin belirli bir işlev için ne kadar alana ihtiyacı olduğunu bilmeden arayan EIP'yi bulmakta zorlanırsınız. Elbette Microsoft, bu durumda bile yığın yürüyüşleri yapmanızı sağlayan bir API sağlar, ancak PDB dosyalarındaki sembol tablosu veritabanına bakmak bazı kullanım durumları için çok uzun sürer.

Derleme birimlerinizde FPO'dan kaçınmak için, / O2 kullanmaktan kaçınmanız veya projelerinizdeki C ++ derleme bayraklarına açıkça / Oy- eklemeniz gerekir. Muhtemelen Release konfigürasyonunda FPO kullanan C veya C ++ çalışma zamanı ile bağlantı kuruyorsunuz, bu nedenle dbghlp.dll olmadan yığın yürüyüşleri yapmakta zorlanacaksınız.

Her şeyden önce, x86 yığınları yüksek adres değerlerinden düşük adres değerlerine kadar oluşturulduğundan, yığın işaretçisi yığının altını gösterir. Yığın işaretçisi sonraki itme (veya arama) aramasının bir sonraki değeri yerleştireceği noktadır. İşlemi C / C ++ ifadesine eşdeğerdir:

 // push eax
 --*esp = eax
 // pop eax
 eax = *esp++;

 // a function call, in this case, the caller must clean up the function parameters
 move eax,some value
 push eax
 call some address  // this pushes the next value of the instruction pointer onto the
                    // stack and changes the instruction pointer to "some address"
 add esp,4 // remove eax from the stack

 // a function
 push ebp // save the old stack frame
 move ebp, esp
 ... // do stuff
 pop ebp  // restore the old stack frame
 ret

Temel işaretçi geçerli çerçevenin üstündedir. ebp genellikle dönüş adresinizi gösterir. ebp + 4 işlevinizin ilk parametresini (veya bir sınıf yönteminin bu değerini) gösterir. ebp-4, işlevin ilk yerel değişkenini, genellikle ebp'in eski değerini gösterir, böylece önceki kare işaretçisini geri yükleyebilirsiniz.

Montaj programlamasını yaptığımdan bu yana uzun zaman geçti, ancak bu bağlantı faydalı olabilir ...

İşlemcinin veri depolamak için kullanılan bir kayıt koleksiyonu vardır. Bunların bazıları doğrudan değerlerdir, diğerleri ise RAM içindeki bir alanı gösterir. Kayıtlar belirli eylemler için kullanılma eğilimindedir ve montajdaki her işlenen belirli kayıtlarda belirli miktarda veri gerektirir.

Yığın işaretçisi çoğunlukla diğer yordamları çağırırken kullanılır. Modern derleyicilerle, ilk önce yığına bir grup veri dökülür, ardından dönüş adresi gelir, böylece sistem geri dönmesi söylendiğinde nereye geri döneceğini bilir. Yığın işaretçisi, yığına yeni verilerin gönderilebileceği bir sonraki yeri gösterecek ve burada tekrar geri açılana kadar kalacaktır.

Baz kayıtları veya segment kayıtları, büyük miktarda verinin adres alanını gösterir. İkinci bir kayıt cihazı ile birleştirildiğinde, Temel işaretçi belleği büyük bloklara bölerken ikinci kayıt bu blok içindeki bir öğeye işaret eder. Bunun için taban işaretçileri veri bloklarının tabanını gösterir.

Assembly'nin CPU'ya özgü olduğunu unutmayın. Bağlantı verdiğim sayfa farklı CPU tipleri hakkında bilgi veriyor.

Düzenle Evet, bu çoğunlukla yanlış. Herkesin ilgilenmesi durumunda tamamen farklı bir şey açıklar :)

Evet, yığın işaretçisi yığının üstünü işaret eder (ister ilk boş yığın konumu ister emin olmadığım son dolu konum). Temel işaretçi, yürütülmekte olan komutun bellek konumunu işaret eder. Bu opcode seviyesindedir - bir bilgisayarda alabileceğiniz en temel talimat. Her opcode ve parametreleri bir bellek konumunda saklanır. Bir C veya C ++ veya C # satırı, ne kadar karmaşık olduğuna bağlı olarak bir opcode'a veya iki veya daha fazla diziye çevrilebilir. Bunlar sırayla program belleğine yazılır ve yürütülür. Normal şartlar altında temel işaretçi bir komut arttırılır. Program kontrolü için (GOTO, IF, vb.) Birden çok kez artırılabilir veya sadece bir sonraki bellek adresiyle değiştirilebilir.

Bu bağlamda, fonksiyonlar belirli bir adresteki program belleğinde saklanır. İşlev çağrıldığında, programın işlevin çağrıldığı yere geri döndüğünü bulmasını sağlayan yığına belirli bilgiler itilir ve işleve ait parametreler daha sonra program belleğindeki işlevin adresi temel işaretçi. Bir sonraki saat döngüsünde bilgisayar bu bellek adresinden talimatlar vermeye başlar. Sonra bir noktada işlevi çağıran komuttan sonra hafıza konumuna dönecek ve oradan devam edecektir.

esp "Genişletilmiş Stack Pointer" anlamına gelir ..... "Something Base Pointer" için ebp .... ve "Something Talimat Pointer" için eip ...... Stack Pointer, yığın segmentinin ofset adresini işaret eder . Temel İşaretçi, ekstra segmentin ofset adresini işaret eder. Yönerge İşaretçisi, kod segmentinin ofset adresini gösterir. Şimdi, segmentler hakkında ... işlemcilerin bellek alanının küçük 64KB bölümler ..... Bu işlem Bellek Segmentasyon olarak bilinir. Umarım bu yazı yardımcı olmuştur.