C 在mips32中表示一个结构

我在为考试学习Mips32，最近我在想如何在mips中翻译c结构。 一般来说，我对mips和汇编代码相当陌生，但我已尝试收集所有知识来制定解决方案

假设我有一个简单的C结构：

struct Student
{
    int id;
};

int main()
{
    struct Student student;
    student={111111};
    return 0;
}

我的想法是将所有数据存储在堆栈中，如下所示：

sub $sp,$sp,4
li  $t1,111111
sw  $t1,($sp)

如果我有多个学生，我只需创建一个例程，将参数存储在堆栈中。 但是我有个问题，我怎么能跟踪所有的学生？ 也许用帧指针

---

我不知道这是否适合在mips中表示结构，请告诉我是否有更好的解决方案。

您的数据可以是本地、静态或动态分配的。没有一条规则。 见：

#包括
#包括
#包括
#包括
类型定义结构
{
int x；
int-y[4]；
字符名[23]；
}我的结构；
我的结构我的全局结构[10]；
作废我的\u全局\u结构\u foo（作废）
{
用于（大小\u t pos=0；pos<10；pos++）
{
我的全局结构[pos].x=rand（）；
我的全局结构[pos].y[0]=我的全局结构[pos].x/2；
my_global_struct[pos].name[4]=my_global_struct[pos].y[0]；
}
}
void my\u static\u struct\u foo（void）
{
静态MYSTRUCT\t myu静态结构[10]；
用于（大小\u t pos=0；pos<10；pos++）
{
my_static_struct[pos].x=rand（）；
my_static_struct[pos].y[0]=my_static_struct[pos].x/2；
my_static_struct[pos].name[4]=my_static_struct[pos].y[0]；
}
}
void my\u local\u struct\u foo（void）
{
volatile MYSTRUCT\t my\u local\u struct[10]；
用于（大小\u t pos=0；pos<10；pos++）
{
my_local_struct[pos].x=rand（）；
my_local_struct[pos].y[0]=rand（）；
my_local_struct[pos].name[4]=rand（）；
}
}

您的数据可以是本地、静态或动态分配的。没有一条规则。 见：

#包括
#包括
#包括
#包括
类型定义结构
{
int x；
int-y[4]；
字符名[23]；
}我的结构；
我的结构我的全局结构[10]；
作废我的\u全局\u结构\u foo（作废）
{
用于（大小\u t pos=0；pos<10；pos++）
{
我的全局结构[pos].x=rand（）；
我的全局结构[pos].y[0]=我的全局结构[pos].x/2；
my_global_struct[pos].name[4]=my_global_struct[pos].y[0]；
}
}
void my\u static\u struct\u foo（void）
{
静态MYSTRUCT\t myu静态结构[10]；
用于（大小\u t pos=0；pos<10；pos++）
{
my_static_struct[pos].x=rand（）；
my_static_struct[pos].y[0]=my_static_struct[pos].x/2；
my_static_struct[pos].name[4]=my_static_struct[pos].y[0]；
}
}
void my\u local\u struct\u foo（void）
{
volatile MYSTRUCT\t my\u local\u struct[10]；
用于（大小\u t pos=0；pos<10；pos++）
{
my_local_struct[pos].x=rand（）；
my_local_struct[pos].y[0]=rand（）；
my_local_struct[pos].name[4]=rand（）；
}
}

但是我有个问题，我怎么能跟踪所有的学生？也许用帧指针

您不需要帧指针来跟踪所有学生。此外，跟踪它们的问题并不是它们的结构所独有的——跟踪许多整数也会遇到同样的问题。此外，跟踪许多项目的问题也不是组装所独有的

您需要的是每个项目都有一个单独的变量（通常是不切实际的，尤其是在项目数量可变的情况下），或者是一个数据结构：某种类型的集合，例如数组或链表

---

在C中使用单独的局部变量时，每个变量都需要不同的名称，在汇编中，每个变量在堆栈框架中都有不同的偏移量/位置。所有指令的堆栈空间将在一条指令中分配，并且它们都通过各自相对于堆栈指针的偏移量进行引用

如果愿意，可以使用帧指针，但由于使用MIPS，函数堆栈帧的堆栈空间都在中的一条指令中分配，因此堆栈指针在函数体期间不会移动，这意味着各个变量与堆栈指针的偏移量保持不变

---

如果出现以下情况之一，则帧指针可能会有所帮助：

• 机器不能很好地进行堆栈相对偏移，但可以轻松地进行帧指针相对偏移，或者
• 机器需要频繁地推动和弹出以移动堆栈指针，从而更改访问堆栈帧中相同位置所需的偏移量-无论推动和弹出如何，帧指针都保持不变。（如果CPU寄存器不足，例如在表达式计算期间，推送和弹出可用于参数传递和/或临时存储。）
• 一种动态分配堆栈空间的函数，例如通过C

一般来说，前两个不适用于MIPS，因此函数通常不需要帧指针

---

或者，您可以使用类似数组的数据结构来跟踪许多项。数组本身需要一个变量（在C中是一个名称，在汇编中是一个偏移量）来引用，但不管要跟踪多少项，至少只有一个变量。然后，您就可以通过索引来访问各个元素。（索引涉及计算元素的地址，这取决于元素的大小，但对于int数组和struct数组，其操作方式相同。）

但是我有个问题，我怎么能跟踪所有的学生？也许用帧指针

您不需要帧指针来跟踪所有学生。此外，跟踪它们的问题并不是它们的结构所独有的——跟踪许多整数也会遇到同样的问题。此外，跟踪许多项目的问题也不是组装所独有的

您需要的是每个项目都有一个单独的变量（通常是不切实际的，尤其是在项目数量可变的情况下），或者是一个da

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>

typedef struct
{
    int x;
    int y[4];
    char name[23];
}MYSTRUCT_t;



MYSTRUCT_t my_global_struct[10];

void my_global_struct_foo(void)
{
    for(size_t pos = 0; pos < 10; pos++)
    {
        my_global_struct[pos].x = rand();
        my_global_struct[pos].y[0] = my_global_struct[pos].x / 2;
        my_global_struct[pos].name[4] = my_global_struct[pos].y[0];
    }
}

void my_static_struct_foo(void)
{
    static MYSTRUCT_t my_static_struct[10];

    for(size_t pos = 0; pos < 10; pos++)
    {
        my_static_struct[pos].x = rand();
        my_static_struct[pos].y[0] = my_static_struct[pos].x / 2;
        my_static_struct[pos].name[4] = my_static_struct[pos].y[0];
    }
}

void my_local_struct_foo(void)
{
    volatile MYSTRUCT_t my_local_struct[10];

    for(size_t pos = 0; pos < 10; pos++)
    {
        my_local_struct[pos].x = rand();
        my_local_struct[pos].y[0] = rand();
        my_local_struct[pos].name[4] = rand();
    }
}

std_struct: .align 2
           .space 40   # 10students, 1 word=4 bytes each
.text

main:

la $s0, std_struct #now everything should be parsable via $s0 register