MIPS程序集中的面向对象的继承

Question

我是一名计算机科学专业的学生，​​目前正在学习编译课程，我们在该课程中有一个项目旨在使用IC语言（它是Java语言的一个子集）构建编译器。 我在最后一部分需要生成MIPS程序集，而无需从IR树分配寄存器。
我试图了解对象实例如何在MIPS程序集中表示。 我确实知道我需要为每个对象实例生成一个虚拟功能表 （其中包含与该实例相关的功能的地址）。
我的问题是：
我是否需要为类字段做一个类似的表，因为字段也是继承的。 您会怎么建议呢？
此外，如果有人可以举一个实例，说明继承类和字段的对象实例的真实MIPS汇编代码是什么样的，我将不胜感激。
例如，MIPS代码的外观如下：

class A{
    int x;
    void f(){}
}

class B extends A{
    int y;
    void g(){}

    void main(){
      A newObj = new B();
      newObj.f();
      newObj.x++;
    }
}

Answer 1

我只解决这部分问题：

此外，如果有人能给出一个真实的MIPS汇编代码外观示例，我将不胜感激。

我确实以某种方式将您的示例重写为C ++，即带有少量开关的C ++编译器不会完全优化它，并且不会保留字段和调用（如果您想知道为什么使用volatile等功能，只是为了防止编译器产生汇编程序例如return value = 5, return ...当您只想看一些“示例”代码时return value = 5, return C ++编译器的优化往往会令人讨厌。

class A {
  public:
    volatile int x;
    virtual void f(){
      ++x;
    }
};

class B : public A {
  public:
    volatile int y;
    B(int i) {
      y = i;
      x = i-1;
    }
    virtual void f(){
      x += 2;
    }
    void g() {
      f();
      x += 3;
      ++y;
    }
};

int footest(int in) {
  B* obj = new B(in);
  A* obj_A_alias = obj;
  obj_A_alias->f();     // calling B::f(), because f is virtual
  obj->g();
  obj->f();
  obj->A::f();          // forcing A::f() call (on B instance)
  int result = obj->x + obj->y;
  delete obj;
  return result;
}

现在，如果将其放入http://godbolt.org/并使用选项-O3 -std=c++11 -fno-loop-optimize -fno-inline将编译器设置为MIPS gcc 5.4，您将获得此输出：

$LFB0 = .
A::f():
$LVL0 = .
        lw      $2,4($4)
        addiu   $2,$2,1
        sw      $2,4($4)
        j       $31
        nop

$LFB7 = .
B::f():
$LVL1 = .
        lw      $2,4($4)
        addiu   $2,$2,2
        sw      $2,4($4)
        j       $31
        nop

$LFB3 = .
A::A():
$LVL2 = .
$LBB2 = .
        lui     $2,%hi(vtable for A+8)
        addiu   $2,$2,%lo(vtable for A+8)
        j       $31
        sw      $2,0($4)

$LBE2 = .
        A::A() = A::A()
$LFB5 = .
B::B(int):
$LVL3 = .
        addiu   $sp,$sp,-40
        sw      $17,32($sp)
        move    $17,$5
        sw      $31,36($sp)
        sw      $16,28($sp)
$LBB3 = .
        jal     A::A()
        move    $16,$4

$LVL4 = .
        addiu   $2,$17,-1
$LBE3 = .
        lw      $31,36($sp)
$LBB4 = .
        sw      $17,8($16)
        sw      $2,4($16)
        lui     $2,%hi(vtable for B+8)
$LBE4 = .
        lw      $17,32($sp)
$LVL5 = .
$LBB5 = .
        addiu   $2,$2,%lo(vtable for B+8)
        sw      $2,0($16)
$LBE5 = .
        lw      $16,28($sp)
$LVL6 = .
        j       $31
        addiu   $sp,$sp,40

        B::B(int) = B::B(int)
$LFB8 = .
B::g():
$LVL7 = .
        lw      $2,0($4)
        addiu   $sp,$sp,-32
        sw      $16,24($sp)
        sw      $31,28($sp)
        lw      $25,0($2)
        jalr    $25
        move    $16,$4

$LVL8 = .
        lw      $2,4($16)
        lw      $31,28($sp)
        addiu   $2,$2,3
        sw      $2,4($16)
        lw      $2,8($16)
        addiu   $2,$2,1
        sw      $2,8($16)
        lw      $16,24($sp)
$LVL9 = .
        j       $31
        addiu   $sp,$sp,32

$LFB9 = .
footest(int):
$LVL10 = .
        lui     $28,%hi(__gnu_local_gp)
        addiu   $sp,$sp,-32
        addiu   $28,$28,%lo(__gnu_local_gp)
        sw      $16,24($sp)
        move    $16,$4
$LVL11 = .
        sw      $31,28($sp)
        lw      $25,%call16(operator new(unsigned int))($28)
1:      jalr        $25
        li      $4,12                 # 0xc

$LVL12 = .
        move    $5,$16
        move    $16,$2
$LVL13 = .
        jal     B::B(int)
        move    $4,$2

$LVL14 = .
$LVL15 = .
        jal     B::f()
        move    $4,$16

$LVL16 = .
        jal     B::g()
        move    $4,$16

$LVL17 = .
        lw      $2,0($16)
        lw      $25,0($2)
        jalr    $25
        move    $4,$16

$LVL18 = .
        jal     A::f()
        move    $4,$16

$LVL19 = .
        move    $4,$16
        lw      $28,16($sp)
        lw      $2,4($16)
        lw      $16,8($16)
$LVL20 = .
        lw      $25,%call16(operator delete(void*))($28)
$LVL21 = .
1:      jalr        $25
        addu    $16,$2,$16

$LVL22 = .
        move    $2,$16
        lw      $31,28($sp)
        lw      $16,24($sp)
$LVL23 = .
        j       $31
        addiu   $sp,$sp,32

typeinfo name for A:
        .ascii  "1A\000"
typeinfo for A:
        .word   vtable for __cxxabiv1::__class_type_info+8
        .word   typeinfo name for A
typeinfo name for B:
        .ascii  "1B\000"
typeinfo for B:
        .word   vtable for __cxxabiv1::__si_class_type_info+8
        .word   typeinfo name for B
        .word   typeinfo for A
vtable for A:
        .word   0
        .word   typeinfo for A
        .word   A::f()
vtable for B:
        .word   0
        .word   typeinfo for B
        .word   B::f()

在实际的站点上尝试使用它 ，这样您还将获得彩色的提示，其中代码的哪一部分属于源的哪一部分（如果是目标平台，则还有MIPS64编译器）。

---

编辑：同样，您也应该尝试使用-O0选项，该输出很可能与您可以通过单学生项目合理实现的更多相关。

---

我在MIPS中不够好，无法向您解释发生了什么，也没有时间这样做，但是如果您要生成编译器，则应该比我更了解它。

C ++源代码演示了如何完成虚拟调用（ $LVL17 ），非虚拟父调用（ $LVL18 ），非虚拟自调用（ $LVL16 ）和字段值访问（ $LVL19 ）。

现在，请记住，这是专业优化的工具，因此，如果您以不太理想的解决方案结束，那应该没问题。 另外请记住，Java和C ++的编译有些不同，在Java中，最终结果不像C ++那样“静态”，因此可能您没有足够的信息像C ++那样积极地进行优化。虚拟函数调用只是用目标地址或字段进行硬编码。

毕竟，如果它是Java，则不能指望它是最佳的，对于托管运行时语言来说，它是一种不错的选择，并且与高质量的JIT编译器一起使用，基本代码速度可以与C ++媲美，但是一旦您遇到问题，由于效率低下的Java数据结构，C ++不断发展。