how do I know where "this" pointer is?

[jameschen]

The question is that why ebp-12 is the "this" pointer, how to how?
movl -12(%ebp), %eax //???????????? why ebp-12 is
"this" pointer's address, how to know?
movl (%eax), %eax
addl $4, %eax
movl (%eax), %edx
movl $5, 4(%esp)
movl -12(%ebp), %eax //????????????
why ebp-12 is "this" pointer's address, how to know?
movl %eax, (%esp)
call *%edx ///////////
pMyClass->test1();

eg:
#include <iostream>
using namespace std;

class MyClass
{
public:
MyClass(){ data1 =1; data2 = 2;};
~MyClass(){};
int data1;
int data2;
int data3;
void print(int data2)
{
cout << "hello! data1: " << data1 << " data2: " << data2 <<
endl;
}

virtual void test1()
{
data2 = 4;
}
};

int main()
{
MyClass * pMyClass;
pMyClass = new MyClass;
cout << "sizeof(MyClass) = " << sizeof(MyClass) << endl;
pMyClass->test1();
pMyClass->print(4); // 1: ÕýÈ·µ÷ÓÃ

return 0;
}

The ASM code of the example is:
#################

.globl main
.type main, @function
main:
.LFB1401:
leal 4(%esp), %ecx
.LCFI19:
andl $-16, %esp
pushl -4(%ecx)
.LCFI20:
pushl %ebp
.LCFI21:
movl %esp, %ebp
.LCFI22:
pushl %ebx
.LCFI23:
pushl %ecx
.LCFI24:
subl $32, %esp
.LCFI25:
movl $16, (%esp)
call _Znwj
movl %eax, %ebx
movl %ebx, (%esp)
call _ZN7MyClassC1Ev
movl %ebx, -12(%ebp)
movl $.LC2, 4(%esp)
movl $_ZSt4cout, (%esp)
call
_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
movl $16, 4(%esp)
movl %eax, (%esp)
call _ZNSolsEj
movl
$_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_, 4(%esp)
movl %eax, (%esp)
call _ZNSolsEPFRSoS_E
movl -12(%ebp), %eax
movl (%eax), %eax
addl $4, %eax
movl (%eax), %edx
movl $5, 4(%esp)
movl -12(%ebp), %eax //????????????
why ebp-12 is "this" pointer's address, how to know?
movl %eax, (%esp)
call *%edx ///////////
pMyClass->test1();
movl $4, 4(%esp)
movl -12(%ebp), %eax
movl %eax, (%esp)
call _ZN7MyClass5printEi ///////pMyClass-

print(4);

movl $0, %eax
addl $32, %esp
popl %ecx
popl %ebx
popl %ebp
leal -4(%ecx), %esp
ret
.LFE1401:
.size main, .-main
.local _ZSt8__ioinit
.comm _ZSt8__ioinit,1,1
.weak _ZTV7MyClass
.section .gnu.linkonce.r._ZTV7MyClass,"a",@progbits
.align 8
.type _ZTV7MyClass, @object
.size _ZTV7MyClass, 16
_ZTV7MyClass:
.long 0
.long _ZTI7MyClass
.long _ZN7MyClass4testEv
.long _ZN7MyClass5test1Ei
.weak _ZTI7MyClass
.section .gnu.linkonce.r._ZTI7MyClass,"a",@progbits
.align 4
.type _ZTI7MyClass, @object
.size _ZTI7MyClass, 8
_ZTI7MyClass:
.long _ZTVN10__cxxabiv117__class_type_infoE+8
.long _ZTS7MyClass
.weak _ZTS7MyClass
.section .gnu.linkonce.r._ZTS7MyClass,"a",@progbits
.type _ZTS7MyClass, @object
.size _ZTS7MyClass, 9
_ZTS7MyClass:
.string "7MyClass"
.section .eh_frame,"a",@progbits
.

 

[jameschen]

The question is that why ebp-12 is the "this" pointer, how to how?
movl -12(%ebp), %eax //???????????? why ebp-12 is
"this" pointer's address, how to know?
movl (%eax), %eax
addl $4, %eax
movl (%eax), %edx
movl $5, 4(%esp)
movl -12(%ebp), %eax //????????????
why ebp-12 is "this" pointer's address, how to know?
movl %eax, (%esp)
call *%edx ///////////
pMyClass->test1();

eg:
#include <iostream>
using namespace std;

class MyClass
{
public:
MyClass(){ data1 =1; data2 = 2;};
~MyClass(){};
int data1;
int data2;
int data3;
void print(int data2)
{
cout << "hello! data1: " << data1 << " data2: " << data2 <<
endl;
}

virtual void test1()
{
data2 = 4;
}

};

int main()
{
MyClass * pMyClass;
pMyClass = new MyClass;
cout << "sizeof(MyClass) = " << sizeof(MyClass) << endl;
pMyClass->test1();
pMyClass->print(4); // 1: ÕýÈ·µ÷ÓÃ

return 0;

}

The ASM code of the example is:
#################

.globl main
.type main, @function
main:
.LFB1401:
leal 4(%esp), %ecx
.LCFI19:
andl $-16, %esp
pushl -4(%ecx)
.LCFI20:
pushl %ebp
.LCFI21:
movl %esp, %ebp
.LCFI22:
pushl %ebx
.LCFI23:
pushl %ecx
.LCFI24:
subl $32, %esp
.LCFI25:
movl $16, (%esp)
call _Znwj
movl %eax, %ebx
movl %ebx, (%esp)
call _ZN7MyClassC1Ev
movl %ebx, -12(%ebp)
movl $.LC2, 4(%esp)
movl $_ZSt4cout, (%esp)
call
_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
movl $16, 4(%esp)
movl %eax, (%esp)
call _ZNSolsEj
movl
$_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_, 4(%esp)
movl %eax, (%esp)
call _ZNSolsEPFRSoS_E
movl -12(%ebp), %eax
movl (%eax), %eax
addl $4, %eax
movl (%eax), %edx
movl $5, 4(%esp)
movl -12(%ebp), %eax //????????????
why ebp-12 is "this" pointer's address, how to know?
movl %eax, (%esp)
call *%edx ///////////
pMyClass->test1();
movl $4, 4(%esp)
movl -12(%ebp), %eax
movl %eax, (%esp)
call _ZN7MyClass5printEi ///////pMyClass->print(4);

movl $0, %eax
addl $32, %esp
popl %ecx
popl %ebx
popl %ebp
leal -4(%ecx), %esp
ret
.LFE1401:
.size main, .-main
.local _ZSt8__ioinit
.comm _ZSt8__ioinit,1,1
.weak _ZTV7MyClass
.section .gnu.linkonce.r._ZTV7MyClass,"a",@progbits
.align 8
.type _ZTV7MyClass, @object
.size _ZTV7MyClass, 16
_ZTV7MyClass:
.long 0
.long _ZTI7MyClass
.long _ZN7MyClass4testEv
.long _ZN7MyClass5test1Ei
.weak _ZTI7MyClass
.section .gnu.linkonce.r._ZTI7MyClass,"a",@progbits
.align 4
.type _ZTI7MyClass, @object
.size _ZTI7MyClass, 8
_ZTI7MyClass:
.long _ZTVN10__cxxabiv117__class_type_infoE+8
.long _ZTS7MyClass
.weak _ZTS7MyClass
.section .gnu.linkonce.r._ZTS7MyClass,"a",@progbits
.type _ZTS7MyClass, @object
.size _ZTS7MyClass, 9
_ZTS7MyClass:
.string "7MyClass"
.section .eh_frame,"a",@progbits
.

I don't know whether I describe the question clear or not£¿

 

[red floyd]

The question is that why ebp-12 is the "this" pointer, how to how?
movl -12(%ebp), %eax //???????????? why ebp-12 is
"this" pointer's address, how to know?

[assembly code redacted]

It's implementation specific. You should ask in a newsgroup dedicated
to your compiler and platform.

Why do you want to know?

 

[jason.cipriani]

The question is that why ebp-12 is the "this" pointer, how to how?

Like Red said it's implementation-specific. However, many compilers
that I've seen implement class member functions by passing a pointer
to the instance data ("this") to the member functions as a "hidden"
parameter. Similar (sort of) to doing, say, this:

struct Something {
int data;
};

void SomeMemberFunction (Something *s, int param) {
s->data = param;
}

In order to emulate this:

class Something {
int data;
void SomeMemberFunction (int param) {
data = param;
}
};

And so the "this" pointer is passed as a parameter to the member
function on the stack; since that info needs to be available inside
the member function.

Again, that's implementation specific, that's only a general summary,
AFAIK there's nothing standardized about that. I wouldn't rely on it
being at EBP-12 even with the same compiler. It may also depend on
compiler options used, the number of other parameters the function
takes, the calling convention, and many other things that you can't
rely on.

Why do you want to know?

Yes; unless you are just trying to satisfy your curiosity, if you are
considering doing something strange you may want to consider other
simpler methods before doing whatever it is you are doing.

Jason

 

[jameschen]

Thank you for your post.

Like Red said it's implementation-specific. However, many compilers
that I've seen implement class member functions by passing a pointer
to the instance data ("this") to the member functions as a "hidden"
parameter. Similar (sort of) to doing, say, this:

struct Something {
int data;
};

void SomeMemberFunction (Something *s, int param) {
s->data = param;
}

In order to emulate this:

class Something {
int data;
void SomeMemberFunction (int param) {
data = param;
}
};

And so the "this" pointer is passed as a parameter to the member
function on the stack; since that info needs to be available inside
the member function.

Again, that's implementation specific, that's only a general summary,
AFAIK there's nothing standardized about that. I wouldn't rely on it
being at EBP-12 even with the same compiler. It may also depend on
compiler options used, the number of other parameters the function
takes, the calling convention, and many other things that you can't
rely on.



Yes; unless you are just trying to satisfy your curiosity, if you are
considering doing something strange you may want to consider other
simpler methods before doing whatever it is you are doing.

Jason