C++与汇编小结

C++与汇编小结


本文通过C++反编译,帮助理解C++中的一些概念(指针引用、this指针、虚函数、析构函数、lambda表达式), 希望能在深入理解C++其它一些高级特性(多重继承、RTTI、异常处理)能起到抛砖引玉的作用吧。

指针和引用

引用类型的存储方式和指针是一样的,都是使用内存空间存放地址值。 只是引用类型是通过编译器实现寻址,而指针需要手动寻址。

void funRef(int &ref){
    ref++;
}

int main(){
    //定义int类型变量
    int var = 0x41;
    //int指针变量,初始化为变量var的地址
    int *pnVar = &var;
    //取出指针pcVar指向的地址内容并显示
    char *pcVar = (char*)&var;
    printf("%s",pcVar);

    //引用作为参数,即把var的地址作为参数
    funRef(var);

    return 0;
}

用godbolt查看的效果如图,C++代码与对应的汇编代码用相同的颜色标注,非常方便查看。


switch

在分支数少的情况下可以用if–else if模拟, 但是分支比较大的情况下,需要比较的次数太多, 如果是有序线性的数值,可将每个case语句块的地址预先保存在数组中, 考察switch语句的参数,并依次查询case语句块地址的数组, 从而得到对应case语句块的首地址, 这样可以降低比较的次数,提升效率。

int main(){
    int nIdx=1;
    scanf("%d",&nIdx);

    int result = 0;
    switch(nIdx){
        case 1:
            result = 1;
            break;
        case 2:
            result = 2;
            break;  
        case 3:
            result = 3;
            break;
        case 5:
            result = 3;
            break;  
        case 7:
            result = 3;
            break;      
    }

    return result;
}

如下图,编译器把switch跳转表放到了.L4所指向的区域,其中的元素.L2、.L3 … .L8指向case对应代码地址。


this指针

this指针中保存了所属对象的首地址。

在调用成员函数的过程中,编译器利用rdi寄存器保存了对象的首地址, 并以寄存器传参的方式传递到成员函数中。

#include <stdio.h>

class Location{
public:
    Location(){
        //this指针指向一块16字节的内存区域
        m_x = 1;
        //m_x是一个8字节类型,所以mov一个4字
        //mov     DWORD PTR [rax], 1
        m_y = 2;
        //mov     WORD PTR [rax+4], 2
    }

    short getY(){
        //获取this指针(对象首地址)偏移4处的数据,即m_y的值
        //movzx   eax, WORD PTR [rbp-8+4]
        return m_y;
    }

private:
    int m_x; //占4字节
    short m_y; //占2字节
    //由于内存对齐,整个对象占8字节
};


int main(){
    //在栈上分配16字节,其中有8字节分配给是loc
    //把栈上loc的内存地址(即this指针)作为参数调用Location构造函数。
    Location loc;

    //把栈上loc的内存地址(即this指针)作为参数调用getY成员函数。
    short y = loc.getY();
    //y变量位于[rbp-2]处
    //mov     WORD PTR [rbp-2], ax
    return 0;
}

对应的汇编如下:

虚函数和虚表

编译器会为每一个包含虚函数的类(或通过继承得到的子类)生成一个表,其中包含指向类中每一个虚函数的指针。 这样的表就叫做虚表(vtable)。 此外,每个包含虚函数的类都获得另外一个数据成员,用于在运行时指向适当的虚表。 这个成员通常叫做虚表指针(vtable pointer),并且是类中的第一个数据成员。

在运行时创建对象时,对象的虚表指针将设置为指向合适的虚表。 如果该对象调用一个虚函数,则通过在该对象的虚表中进行查询来选择正确的函数。

代码举例如下,详细代码在这里

class BaseClass {
public:
   BaseClass(){x=1;y=2;};
   virtual void vfunc1() = 0;
   virtual void vfunc2(){};
   virtual void vfunc3();
   virtual void vfunc4(){};
   void hello(){printf("hello,y=%d",this->y);};
private:
   int x;//4字节
   int y;
};

class SubClass : public BaseClass {
public:
   SubClass(){z=3;};
   virtual void vfunc1(){};
   virtual void vfunc3();
   virtual void vfunc5(){};
private:
   int z;
};

虚表布局

下图是一个简化后的内存布局,它动态分配了一个SubClass类型的对象,编译器会确保该对象的第一个字段虚表指针指向正确的虚表。虚表指向编译器为每个类在只读段创建的一块区域,即虚表,类似于数组,其中的大部分元素指向在代码段中的成员函数地址。C++编译器会在编译阶段给这些函数名做name mangling,以实现c++中函数重载、namespace等标准。

vtable for SubClass:
        .quad   0
        .quad   typeinfo for SubClass ;RTTI相关
        .quad   SubClass::vfunc1() ;this指针中的虚表指针一般指向这个偏移处
        .quad   BaseClass::vfunc2()
        .quad   SubClass::vfunc3()
        .quad   BaseClass::vfunc4()
        .quad   SubClass::vfunc5()
vtable for BaseClass:
        .quad   0
        .quad   typeinfo for BaseClass ;RTTI相关
        .quad   __cxa_pure_virtual ;vfunc1是纯虚函数
        .quad   BaseClass::vfunc2()
        .quad   BaseClass::vfunc3()
        .quad   BaseClass::vfunc4()

SubClass 中包含两个指向属于BaseClass的函数( BaseClass::vfunc2 和 BaseClass::vfunc4)的指针。 这是因为 SubClass 并没有重写这2个函数,而是直接继承自BaseClass 。 由于没有针对纯虚函数BaseClass::vfunc1的实现,因此,在 BaseClass的虚表中并没有存储 vfunc1 的地址。 这时,编译器会插入一个错误处理函数的地址,名为 purecall,万一被调用,它会令程序终止或者其他编译器想要发生的行为。 另外,一般的成员函数不在虚表里面,因为不涉及动态调用,如BaseClass中的hello()函数。

创建对象

这里已在堆上动态创建对象为例。 调用new操作符,在堆上动态分配一块SubClass大小的内存,rax指向这块内存的开始。 SubClass需要的内存大小为24字节=8(虚表指针)+4*3(3个int类型的成员变量)+4(内存对齐) 对象首地址的值作为参数调用SubClass构造函数。

   BaseClass *a_ptr = new SubClass();
main:
        ;...
        mov     edi, 24 ;SubClass需要24字节的内存
        call    operator new(unsigned long)
        mov     rbx, rax
        mov     rdi, rbx ;this指针作为参数
        call    SubClass::SubClass()

SubClass的构造函数,在完成自身的任务之前会调用基类的构造函数,然后对this指针的内存的虚表指针修改为指向SubClass自身的虚表。

SubClass::SubClass():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     QWORD PTR [rbp-8], rdi
        mov     rax, QWORD PTR [rbp-8]
        mov     rdi, rax ;this指针
        call    BaseClass::BaseClass()
        mov     edx, OFFSET FLAT:vtable for SubClass+16 ;指向SubClass虚表
        mov     rax, QWORD PTR [rbp-8]
        mov     QWORD PTR [rax], rdx ;this指针的虚表指针字段赋值
        mov     rax, QWORD PTR [rbp-8]
        mov     DWORD PTR [rax+16], 3 ;z=3
        nop
        leave
        ret

BaseClass的构造函数:

BaseClass::BaseClass():
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi ;this指针
        mov     edx, OFFSET FLAT:vtable for BaseClass+16 ;指向BaseClass虚表
        mov     rax, QWORD PTR [rbp-8]
        mov     QWORD PTR [rax], rdx ;this指针的虚表指针字段赋值
        mov     rax, QWORD PTR [rbp-8]
        mov     DWORD PTR [rax+8], 1 ;x=1
        mov     rax, QWORD PTR [rbp-8]
        mov     DWORD PTR [rax+12], 2 ;y=2
        nop
        pop     rbp
        ret

调用成员函数

1、非虚函数

hello()是类BaseClass中的非虚成员函数,不需要通过虚表查找,编译器直接生成调用语句call BaseClass::hello(),并且第一个参数默认为this指针。

    BaseClass *a_ptr = new SubClass();
   //一般的成员函数,不在虚表里
   a_ptr->hello();
main:
        ;...        
        mov     rdi, rax ;参数:this指针
        call    BaseClass::hello()

.LC0:
        .string "hello\357\274\214y=%d"
BaseClass::hello():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     QWORD PTR [rbp-8], rdi  ;this指针放到栈上
        mov     rax, QWORD PTR [rbp-8]
        mov     eax, DWORD PTR [rax+12] ;this指针偏移12处,即成员变量y的位置
        mov     esi, eax              ;参数:format的数据,即y的值
        mov     edi, OFFSET FLAT:.LC0 ;参数:format string
        mov     eax, 0                ;参数:fd,指向stdout
        call    printf
        nop
        leave
        ret

2、虚函数

a_ptr是BaseClass类型的指针,动态分配的是SubClass类型的内存。 call_vfunc函数的参数是基类BaseClass,再调用vfunc3函数时需要先根据虚表指针定位到虚表,再通过偏移,解引用找到vfunc3的代码段地址,完成调用。

int main(){
    BaseClass *a_ptr = new SubClass();
    //对象首地址作为参数调用函数call_vfunc
   call_vfunc(a_ptr);
}
void call_vfunc(BaseClass *a) {
   a->vfunc3();
}  
main:
    ;...    
    mov     rax, QWORD PTR [rbp-24]
    mov     rdi, rax ;rax为this指针
    call    call_vfunc(BaseClass*)

call_vfunc(BaseClass*):
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     QWORD PTR [rbp-8], rdi ;把this指针放到栈上
        mov     rax, QWORD PTR [rbp-8]
        mov     rax, QWORD PTR [rax]   ;this指向的内存的开头8个字节的数据复制给rax,即虚表指针
        add     rax, 16                ;找到虚表指针偏移16
        mov     rax, QWORD PTR [rax]   ;虚表指针偏移16处解引用,得到函数的SubClass::vfunc3的地址
        mov     rdx, QWORD PTR [rbp-8]
        mov     rdi, rdx              ;rdi为this指针,作为参数
        call    rax                   ;调用vfunc3
        nop
        leave
        ret   

析构函数

这里以堆分配的对象析构为例,完整代码在这里。 堆分配的对象的析构函数在分配给对象的内存释放之前通过 delete 操作符调用。 其过程如下: 1、如果类拥有任何虚函数,则还原对象的虚表指针,使其指向相关类的虚表。如果一个子类在创建过程中覆盖了虚表指针,就需要这样做。 2、执行程序员为析构函数指定的代码。 3、如果类拥有本身就是对象的数据成员,则执行这些成员的析构函数。 4、如果对象拥有一个超类,则调用超类的析构函数 5、如果是释放堆的对象,则用一个代理析构函数执行1~4步骤,并在最后调用delete操作符释放堆上的对象。

class BaseClass {
public:
   BaseClass(){x=1;y=2;};
   virtual ~BaseClass(){printf("~BaseClass()\n");};
   virtual void vfunc1() = 0;
private:
   int x;//4字节
   int y;
};

class SubClass : public BaseClass {
public:
   SubClass(){z=3;};
   virtual ~SubClass(){printf("~SubClass()\n");};
   virtual void vfunc1(){};
private:
   int z;
};


int main() {
   BaseClass *a_ptr = new SubClass();
   //触发析构 
   delete a_ptr; 
} 
;只读段中的虚表结构
vtable for SubClass:
    .quad   0
    .quad   typeinfo for SubClass
    .quad   SubClass::'scalar deleting destructor' ;代理析构函数的地址
    .quad   SubClass::~SubClass() ;析构函数的地址,这里godbolt没有把它们区分出来
    .quad   SubClass::vfunc1()

main:
     mov     QWORD PTR [rbp-24], rbx  ;rbx为a_ptr的指针
     cmp     QWORD PTR [rbp-24], 0    ;判断a_ptr是否为null,这是编译器加的。
     je      .L9                      ;如果为null直接跳过析构
     mov     rax, QWORD PTR [rbp-24]
     mov     rax, QWORD PTR [rax]
     add     rax, 8                   ;this指针偏移8处,即指向代理析构函数
     mov     rax, QWORD PTR [rax]     ;rax为代理析构函数的地址
     mov     rdx, QWORD PTR [rbp-24] 
     mov     rdi, rdx                 ;参数:this指针
     call    rax                      ;调用代理析构函数

;SubClass的代理析构函数
SubClass::'scalar deleting destructor':
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     QWORD PTR [rbp-8], rdi
        mov     rax, QWORD PTR [rbp-8]
        mov     rdi, rax              ;参数:this指针
        call    SubClass::~SubClass() ;调用析构函数
        mov     rax, QWORD PTR [rbp-8]
        mov     esi, 24               ;参数:释放24字节大小的堆空间
        mov     rdi, rax              ;参数:堆空间的首地址
        call    operator delete(void*, unsigned long) ;释放堆空间
        leave
        ret

 .LC1:
        .string "~SubClass()"       
;SubClass的析构函数,执行析构函数中的代码
SubClass::~SubClass():
    push    rbp
    mov     rbp, rsp
    sub     rsp, 16
    mov     QWORD PTR [rbp-8], rdi
    mov     edx, OFFSET FLAT:vtable for SubClass+16
    mov     rax, QWORD PTR [rbp-8]
    mov     QWORD PTR [rax], rdx      ;还原对象的虚表指针,使其指向相关类的虚表
    mov     edi, OFFSET FLAT:.LC1
    call    puts                      ;调用puts函数,这里编译器把printf调用转换成puts了。
    mov     rax, QWORD PTR [rbp-8]
    mov     rdi, rax                  ;参数:this指针 
    call    BaseClass::~BaseClass()   ;调用基类的析构函数
    nop
    leave
    ret

.LC0:
        .string "~BaseClass()"
;BaseClass的析构函数,执行析构函数中的代码        
BaseClass::~BaseClass():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     QWORD PTR [rbp-8], rdi
        mov     edx, OFFSET FLAT:vtable for BaseClass+16
        mov     rax, QWORD PTR [rbp-8]
        mov     QWORD PTR [rax], rdx
        mov     edi, OFFSET FLAT:.LC0
        call    puts
        nop
        leave
        ret

通过分析C++析构函数的调用过程,我们就知道了为什么C++基类的析构函数要声明为virtual了。我们希望当调用C++基类BaseClass的析构函数时能够触发动态绑定,能够找到当前对象所属类的虚函数表中的析构函数。 如果不声明BaseClass的析构函数为virtual,那么在调用delete a_ptr时,将只会释放BaseClass大小的内存,给SubClass中成员变量分配的内存将得不到释放,从而导致内存泄漏。

C++11中的Lambda表达式

lambda表达式表示一个可调用的代码单元。可以理解为一个未命名的内联函数。 lambda表达式具有如下形式:

[capture list](parameter list) -> return type {function body}

下面定义了一个C++函数,其中有一个lambda表达式。v1之前的&符号指出v1是以引用方式捕获,当lambda返回v1时,它返回的是v1指向对象的值,所以j的值是0,而不是42.

void fcn1(){
    int v1 =42;
    auto f= [&v1] {return v1;};
    v1 = 0;
    auto j = f();
}

对应的反汇编代码如下,可以看到编译器为fcn1中的lambda表达式在代码段中生成了一段指令,当调用这个lambda时就会执行到这段指令,跟普通的函数调用一致。 可以看出传递给fcn1()::{lambda()#1}函数的参数rdi的值其实就是v1变量的地址,所以这个lambda是是采用引用方式捕获变量的。

.Ltext0:
fcn1()::{lambda()#1}::operator()() const:

        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        mov     rax, QWORD PTR [rbp-8]
        mov     rax, QWORD PTR [rax]
        mov     eax, DWORD PTR [rax]
        pop     rbp
        ret
fcn1():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     DWORD PTR [rbp-8], 42
        lea     rax, [rbp-8]
        mov     QWORD PTR [rbp-16], rax
        mov     DWORD PTR [rbp-8], 0
        lea     rax, [rbp-16]
        mov     rdi, rax
        call    fcn1()::{lambda()#1}::operator()() const
        mov     DWORD PTR [rbp-4], eax
        nop
        leave
        ret

参考

《IDA Pro权威指南》 《C++反汇编与逆向分析技术揭秘》 《C++ Primer(第5版)》

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏小工匠技术圈

【小工匠聊密码学】-- Base64算法

1373
来自专栏函数式编程语言及工具

Scalaz(18)- Monad: ReaderWriterState-可以是一种简单的编程语言

  说道FP,我们马上会联想到Monad。我们说过Monad的代表函数flatMap可以把两个运算F[A],F[B]连续起来,这样就可以从程序的意义上形成一种串...

1997
来自专栏xx_Cc的学习总结专栏

iOS底层原理总结 - 探寻OC对象的本质

3915
来自专栏xx_Cc的学习总结专栏

iOS-正则表达式的简单使用

4167
来自专栏java学习

请问你知道什么是栈吗?

1.1栈的概念及记本操作 栈(stack)又称堆栈,是限制在表的一端进行插入和删除的线性表。其限制是仅允许在表的一端进行插入和删除操作,不允许在其他任何位置进行...

3138
来自专栏ShaoYL

OC正则表达式的简单使用

35113
来自专栏Linux驱动

6.QT-简易计算器实现(详解)

3225
来自专栏web前端-

JavaScript运算符和控制语句

语法: switch(n)  {      case 1:      执行代码块 1      break;      case 2:      执行代码块 2...

832
来自专栏李蔚蓬的专栏

Java基础知识的全面巩固_note1(附各种demo code)

上面的cmd中,javac程序是一个Java编译器,它将文件Welcome.java编译成Welcome.class.java程序启动Java虚拟机。虚拟机执行...

902
来自专栏趣学算法

数据结构 第6讲 链栈

进出的一端称为栈顶(top),另一端称为栈底(base)。栈可以用顺序存储,也可以用链式存储。顺序栈和链栈图解:

931

扫码关注云+社区

领取腾讯云代金券