mirror of https://github.com/sunshaoce/rvcc.git
2676 lines
81 KiB
C
2676 lines
81 KiB
C
#include "rvcc.h"
|
||
|
||
#define GP_MAX 8
|
||
#define FP_MAX 8
|
||
|
||
// 输出文件
|
||
static FILE *OutputFile;
|
||
// 记录栈深度
|
||
static int Depth;
|
||
// 记录大结构体的深度
|
||
static int BSDepth;
|
||
// 当前的函数
|
||
static Obj *CurrentFn;
|
||
|
||
// 我们将fs0～fs11两两组对形成6个寄存器对
|
||
// 用于long double类型的存储，每次+2
|
||
static int LDSP;
|
||
|
||
static void genExpr(Node *Nd);
|
||
static void genStmt(Node *Nd);
|
||
|
||
// 输出字符串到目标文件并换行
|
||
__attribute__((format(printf, 1, 2))) static void printLn(char *Fmt, ...) {
|
||
va_list VA;
|
||
|
||
va_start(VA, Fmt);
|
||
vfprintf(OutputFile, Fmt, VA);
|
||
va_end(VA);
|
||
|
||
fprintf(OutputFile, "\n");
|
||
}
|
||
|
||
// 代码段计数
|
||
static int count(void) {
|
||
static int I = 1;
|
||
return I++;
|
||
}
|
||
|
||
// 压栈，将结果临时压入栈中备用
|
||
// sp为栈指针，栈反向向下增长，64位下，8个字节为一个单位，所以sp-8
|
||
// 当前栈指针的地址就是sp，将a0的值压入栈
|
||
// 不使用寄存器存储的原因是因为需要存储的值的数量是变化的。
|
||
static void push(void) {
|
||
printLn(" # 压栈，将a0的值存入栈顶");
|
||
printLn(" addi sp, sp, -8");
|
||
printLn(" sd a0, 0(sp)");
|
||
Depth++;
|
||
}
|
||
|
||
// 弹栈，将sp指向的地址的值，弹出到a1
|
||
static void pop(int Reg) {
|
||
printLn(" # 弹栈，将栈顶的值存入a%d", Reg);
|
||
printLn(" ld a%d, 0(sp)", Reg);
|
||
printLn(" addi sp, sp, 8");
|
||
Depth--;
|
||
}
|
||
|
||
// 对于浮点类型进行压栈
|
||
static void pushF(void) {
|
||
printLn(" # 压栈，将fa0的值存入栈顶");
|
||
printLn(" addi sp, sp, -8");
|
||
printLn(" fsd fa0, 0(sp)");
|
||
Depth++;
|
||
}
|
||
|
||
// 对于浮点类型进行弹栈
|
||
static void popF(int Reg) {
|
||
printLn(" # 弹栈，将栈顶的值存入fa%d", Reg);
|
||
printLn(" fld fa%d, 0(sp)", Reg);
|
||
printLn(" addi sp, sp, 8");
|
||
Depth--;
|
||
}
|
||
|
||
// 对于long double类型进行压栈
|
||
static void pushLD(void) {
|
||
printLn(" # LD压栈，将a0,a1的值存入LD栈顶");
|
||
printLn(" fmv.d.x fs%d, a1", LDSP + 1);
|
||
printLn(" fmv.d.x fs%d, a0", LDSP);
|
||
LDSP += 2;
|
||
if (LDSP > 10)
|
||
error("LDSP can't be larger than 10!");
|
||
}
|
||
|
||
// 对于long double类型进行弹栈
|
||
static void popLD(int Reg) {
|
||
LDSP -= 2;
|
||
if (LDSP < 0)
|
||
error("LDSP can't be less than 0!");
|
||
printLn(" # LD弹栈，将LD栈顶的值存入a%d,a%d", Reg, Reg + 1);
|
||
printLn(" fmv.x.d a%d, fs%d", Reg + 1, LDSP + 1);
|
||
printLn(" fmv.x.d a%d, fs%d", Reg, LDSP);
|
||
}
|
||
|
||
// 对齐到Align的整数倍
|
||
int alignTo(int N, int Align) {
|
||
// (0,Align]返回Align
|
||
return (N + Align - 1) / Align * Align;
|
||
}
|
||
|
||
// 计算给定节点的绝对地址
|
||
// 如果报错，说明节点不在内存中
|
||
static void genAddr(Node *Nd) {
|
||
switch (Nd->Kind) {
|
||
// 变量
|
||
case ND_VAR:
|
||
// VLA可变长度数组是局部变量
|
||
if (Nd->Var->Ty->Kind == TY_VLA) {
|
||
printLn(" # 为VLA生成局部变量");
|
||
printLn(" li t0, %d", Nd->Var->Offset);
|
||
printLn(" add t0, t0, fp");
|
||
printLn(" ld a0, 0(t0)");
|
||
return;
|
||
}
|
||
|
||
// 局部变量
|
||
if (Nd->Var->IsLocal) { // 偏移量是相对于fp的
|
||
printLn(" # 获取局部变量%s的栈内地址为%d(fp)", Nd->Var->Name,
|
||
Nd->Var->Offset);
|
||
printLn(" li t0, %d", Nd->Var->Offset);
|
||
printLn(" add a0, fp, t0");
|
||
return;
|
||
}
|
||
|
||
// 生成位置无关代码
|
||
if (OptFPIC) {
|
||
int C = count();
|
||
printLn(".Lpcrel_hi%d:", C);
|
||
// 线程局部变量
|
||
if (Nd->Var->IsTLS) {
|
||
printLn(" # 获取PIC中TLS%s的地址", Nd->Var->Name);
|
||
// 计算TLS高20位地址
|
||
printLn(" auipc a0, %%tls_gd_pcrel_hi(%s)", Nd->Var->Name);
|
||
// 计算TLS低12位地址
|
||
printLn(" addi a0, a0, %%pcrel_lo(.Lpcrel_hi%d)", C);
|
||
// 获取地址
|
||
printLn(" call __tls_get_addr@plt");
|
||
return;
|
||
}
|
||
|
||
// 函数或者全局变量
|
||
printLn(" # 获取PIC中%s%s的地址",
|
||
Nd->Ty->Kind == TY_FUNC ? "函数" : "全局变量", Nd->Var->Name);
|
||
// 高20位地址，存到a0中
|
||
printLn(" auipc a0, %%got_pcrel_hi(%s)", Nd->Var->Name);
|
||
// 低12位地址，加到a0中
|
||
printLn(" ld a0, %%pcrel_lo(.Lpcrel_hi%d)(a0)", C);
|
||
return;
|
||
}
|
||
|
||
// 线程局部变量
|
||
if (Nd->Var->IsTLS) {
|
||
// 计算TLS高20位地址
|
||
printLn(" lui a0, %%tprel_hi(%s)", Nd->Var->Name);
|
||
// 计算TLS低12位地址
|
||
printLn(" addi a0, a0, %%tprel_lo(%s)", Nd->Var->Name);
|
||
return;
|
||
}
|
||
|
||
// 函数
|
||
if (Nd->Ty->Kind == TY_FUNC) {
|
||
// 定义的函数
|
||
if (Nd->Var->IsDefinition) {
|
||
printLn(" # 获取函数%s的地址", Nd->Var->Name);
|
||
printLn(" la a0, %s", Nd->Var->Name);
|
||
}
|
||
// 外部函数
|
||
else {
|
||
int C = count();
|
||
printLn(" # 获取外部函数的绝对地址");
|
||
printLn(".Lpcrel_hi%d:", C);
|
||
// 高20位地址，存到a0中
|
||
printLn(" auipc a0, %%got_pcrel_hi(%s)", Nd->Var->Name);
|
||
// 低12位地址，加到a0中
|
||
printLn(" ld a0, %%pcrel_lo(.Lpcrel_hi%d)(a0)", C);
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 全局变量
|
||
int C = count();
|
||
printLn(" # 获取全局变量的绝对地址");
|
||
printLn(".Lpcrel_hi%d:", C);
|
||
// 高20位地址，存到a0中
|
||
printLn(" auipc a0, %%got_pcrel_hi(%s)", Nd->Var->Name);
|
||
// 低12位地址，加到a0中
|
||
printLn(" ld a0, %%pcrel_lo(.Lpcrel_hi%d)(a0)", C);
|
||
return;
|
||
// 解引用*
|
||
case ND_DEREF:
|
||
genExpr(Nd->LHS);
|
||
return;
|
||
// 逗号
|
||
case ND_COMMA:
|
||
genExpr(Nd->LHS);
|
||
genAddr(Nd->RHS);
|
||
return;
|
||
// 结构体成员
|
||
case ND_MEMBER:
|
||
genAddr(Nd->LHS);
|
||
printLn(" # 计算成员变量的地址偏移量");
|
||
printLn(" li t0, %d", Nd->Mem->Offset);
|
||
printLn(" add a0, a0, t0");
|
||
return;
|
||
// 函数调用
|
||
case ND_FUNCALL:
|
||
// 如果存在返回值缓冲区
|
||
if (Nd->RetBuffer) {
|
||
genExpr(Nd);
|
||
return;
|
||
}
|
||
break;
|
||
case ND_ASSIGN:
|
||
case ND_COND:
|
||
// 使结构体成员可以通过=或?:访问
|
||
if (Nd->Ty->Kind == TY_STRUCT || Nd->Ty->Kind == TY_UNION) {
|
||
genExpr(Nd);
|
||
return;
|
||
}
|
||
break;
|
||
case ND_VLA_PTR:
|
||
// VLA的指针
|
||
printLn(" # 生成VLA的指针");
|
||
printLn(" li t0, %d", Nd->Var->Offset);
|
||
printLn(" add a0, t0, fp");
|
||
return;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
errorTok(Nd->Tok, "not an lvalue");
|
||
}
|
||
|
||
// 加载a0指向的值
|
||
static void load(Type *Ty) {
|
||
switch (Ty->Kind) {
|
||
case TY_ARRAY:
|
||
case TY_STRUCT:
|
||
case TY_UNION:
|
||
case TY_FUNC:
|
||
case TY_VLA:
|
||
return;
|
||
case TY_FLOAT:
|
||
printLn(" # 访问a0中存放的地址，取得的值存入fa0");
|
||
printLn(" flw fa0, 0(a0)");
|
||
return;
|
||
case TY_DOUBLE:
|
||
printLn(" # 访问a0中存放的地址，取得的值存入fa0");
|
||
printLn(" fld fa0, 0(a0)");
|
||
return;
|
||
case TY_LDOUBLE:
|
||
printLn(" # 访问a0中存放的地址，取得的值存入LD栈当中");
|
||
printLn(" fld fs%d, 8(a0)", LDSP + 1);
|
||
printLn(" fld fs%d, 0(a0)", LDSP);
|
||
LDSP += 2;
|
||
return;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
// 添加无符号类型的后缀u
|
||
char *Suffix = Ty->IsUnsigned ? "u" : "";
|
||
|
||
printLn(" # 读取a0中存放的地址，得到的值存入a0");
|
||
if (Ty->Size == 1)
|
||
printLn(" lb%s a0, 0(a0)", Suffix);
|
||
else if (Ty->Size == 2)
|
||
printLn(" lh%s a0, 0(a0)", Suffix);
|
||
else if (Ty->Size == 4)
|
||
printLn(" lw%s a0, 0(a0)", Suffix);
|
||
else
|
||
printLn(" ld a0, 0(a0)");
|
||
}
|
||
|
||
// 将栈顶值(为一个地址)存入a0
|
||
static void store(Type *Ty) {
|
||
pop(1);
|
||
|
||
switch (Ty->Kind) {
|
||
case TY_STRUCT:
|
||
case TY_UNION:
|
||
printLn(" # 对%s进行赋值", Ty->Kind == TY_STRUCT ? "结构体" : "联合体");
|
||
for (int I = 0; I < Ty->Size; ++I) {
|
||
printLn(" li t0, %d", I);
|
||
printLn(" add t0, a0, t0");
|
||
printLn(" lb t1, 0(t0)");
|
||
|
||
printLn(" li t0, %d", I);
|
||
printLn(" add t0, a1, t0");
|
||
printLn(" sb t1, 0(t0)");
|
||
}
|
||
return;
|
||
case TY_FLOAT:
|
||
printLn(" # 将fa0的值，写入到a1中存放的地址");
|
||
printLn(" fsw fa0, 0(a1)");
|
||
return;
|
||
case TY_DOUBLE:
|
||
printLn(" # 将fa0的值，写入到a1中存放的地址");
|
||
printLn(" fsd fa0, 0(a1)");
|
||
return;
|
||
case TY_LDOUBLE:
|
||
printLn(" # 将LD栈顶值，写入到a1中存放地址");
|
||
LDSP -= 2;
|
||
printLn(" fsd fs%d, 8(a1)", LDSP + 1);
|
||
printLn(" fsd fs%d, 0(a1)", LDSP);
|
||
return;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
printLn(" # 将a0的值，写入到a1中存放的地址");
|
||
if (Ty->Size == 1)
|
||
printLn(" sb a0, 0(a1)");
|
||
else if (Ty->Size == 2)
|
||
printLn(" sh a0, 0(a1)");
|
||
else if (Ty->Size == 4)
|
||
printLn(" sw a0, 0(a1)");
|
||
else
|
||
printLn(" sd a0, 0(a1)");
|
||
};
|
||
|
||
// 与0进行比较，不等于0则置1
|
||
static void notZero(Type *Ty) {
|
||
switch (Ty->Kind) {
|
||
case TY_FLOAT:
|
||
printLn(" # 判断fa1是否不为0，为0置0，非0置1");
|
||
printLn(" fmv.s.x fa1, zero");
|
||
printLn(" feq.s a0, fa0, fa1");
|
||
printLn(" xori a0, a0, 1");
|
||
return;
|
||
case TY_DOUBLE:
|
||
printLn(" # 判断fa1是否不为0，为0置0，非0置1");
|
||
printLn(" fmv.d.x fa1, zero");
|
||
printLn(" feq.d a0, fa0, fa1");
|
||
printLn(" xori a0, a0, 1");
|
||
return;
|
||
case TY_LDOUBLE:
|
||
printLn(" # 判断fa1是否不为0，为0置0，非0置1");
|
||
popLD(0);
|
||
printLn(" mv a2, zero");
|
||
printLn(" mv a3, zero");
|
||
printLn(" call __netf2@plt");
|
||
printLn(" snez a0, a0");
|
||
return;
|
||
default:
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 类型枚举
|
||
enum { I8, I16, I32, I64, U8, U16, U32, U64, F32, F64, F128 };
|
||
|
||
// 获取类型对应的枚举值
|
||
static int getTypeId(Type *Ty) {
|
||
switch (Ty->Kind) {
|
||
case TY_CHAR:
|
||
return Ty->IsUnsigned ? U8 : I8;
|
||
case TY_SHORT:
|
||
return Ty->IsUnsigned ? U16 : I16;
|
||
case TY_INT:
|
||
return Ty->IsUnsigned ? U32 : I32;
|
||
case TY_LONG:
|
||
return Ty->IsUnsigned ? U64 : I64;
|
||
case TY_FLOAT:
|
||
return F32;
|
||
case TY_DOUBLE:
|
||
return F64;
|
||
case TY_LDOUBLE:
|
||
return F128;
|
||
default:
|
||
return U64;
|
||
}
|
||
}
|
||
|
||
// 类型映射表
|
||
// 有符号整型转换
|
||
static char i32f32[] = " # i32转换为f32类型\n"
|
||
" fcvt.s.w fa0, a0";
|
||
static char i32f64[] = " # i32转换为f64类型\n"
|
||
" fcvt.d.w fa0, a0";
|
||
static char i32f128[] = " # i32转换为f128类型\n"
|
||
" call __floatsitf@plt";
|
||
|
||
// 先逻辑左移N位，再算术右移N位，就实现了将64位有符号数转换为64-N位的有符号数
|
||
static char i64i8[] = " # 转换为i8类型\n"
|
||
" slli a0, a0, 56\n"
|
||
" srai a0, a0, 56";
|
||
static char i64i16[] = " # 转换为i16类型\n"
|
||
" slli a0, a0, 48\n"
|
||
" srai a0, a0, 48";
|
||
static char i64i32[] = " # 转换为i32类型\n"
|
||
" slli a0, a0, 32\n"
|
||
" srai a0, a0, 32";
|
||
|
||
// 先逻辑左移N位，再逻辑右移N位，就实现了将64位无符号数转换为64-N位的无符号数
|
||
static char i64u8[] = " # 转换为u8类型\n"
|
||
" slli a0, a0, 56\n"
|
||
" srli a0, a0, 56";
|
||
static char i64u16[] = " # 转换为u16类型\n"
|
||
" slli a0, a0, 48\n"
|
||
" srli a0, a0, 48";
|
||
static char i64u32[] = " # 转换为u32类型\n"
|
||
" slli a0, a0, 32\n"
|
||
" srli a0, a0, 32";
|
||
|
||
// 有符号整型转换为浮点数
|
||
static char i64f32[] = " # i64转换为f32类型\n"
|
||
" fcvt.s.l fa0, a0";
|
||
static char i64f64[] = " # i64转换为f64类型\n"
|
||
" fcvt.d.l fa0, a0";
|
||
static char i64f128[] = " # i64转换为f128类型\n"
|
||
" call __floatditf@plt";
|
||
|
||
// 无符号整型转换
|
||
static char u32f32[] = " # u32转换为f32类型\n"
|
||
" fcvt.s.wu fa0, a0";
|
||
static char u32f64[] = " # u32转换为f64类型\n"
|
||
" fcvt.d.wu fa0, a0";
|
||
static char u32f128[] = " # u32转换为f128类型\n"
|
||
" call __floatunsitf@plt";
|
||
|
||
static char u32i64[] = " # u32转换为i64类型\n"
|
||
" slli a0, a0, 32\n"
|
||
" srli a0, a0, 32";
|
||
|
||
// 无符号整型转换为浮点数
|
||
static char u64f32[] = " # u64转换为f32类型\n"
|
||
" fcvt.s.lu fa0, a0";
|
||
static char u64f64[] = " # u64转换为f64类型\n"
|
||
" fcvt.d.lu fa0, a0";
|
||
static char u64f128[] = " # u64转换为f128类型\n"
|
||
" call __floatunditf@plt";
|
||
|
||
// 单精度浮点数转换为整型
|
||
static char f32i8[] = " # f32转换为i8类型\n"
|
||
" fcvt.w.s a0, fa0, rtz\n"
|
||
" slli a0, a0, 56\n"
|
||
" srai a0, a0, 56";
|
||
static char f32i16[] = " # f32转换为i16类型\n"
|
||
" fcvt.w.s a0, fa0, rtz\n"
|
||
" slli a0, a0, 48\n"
|
||
" srai a0, a0, 48";
|
||
static char f32i32[] = " # f32转换为i32类型\n"
|
||
" fcvt.w.s a0, fa0, rtz\n"
|
||
" slli a0, a0, 32\n"
|
||
" srai a0, a0, 32";
|
||
static char f32i64[] = " # f32转换为i64类型\n"
|
||
" fcvt.l.s a0, fa0, rtz";
|
||
|
||
// 单精度浮点数转换为无符号浮点数
|
||
static char f32u8[] = " # f32转换为u8类型\n"
|
||
" fcvt.wu.s a0, fa0, rtz\n"
|
||
" slli a0, a0, 56\n"
|
||
" srli a0, a0, 56";
|
||
static char f32u16[] = " # f32转换为u16类型\n"
|
||
" fcvt.wu.s a0, fa0, rtz\n"
|
||
" slli a0, a0, 48\n"
|
||
" srli a0, a0, 48\n";
|
||
static char f32u32[] = " # f32转换为u32类型\n"
|
||
" fcvt.wu.s a0, fa0, rtz\n"
|
||
" slli a0, a0, 32\n"
|
||
" srai a0, a0, 32";
|
||
static char f32u64[] = " # f32转换为u64类型\n"
|
||
" fcvt.lu.s a0, fa0, rtz";
|
||
|
||
// 单精度转换为双精度浮点数
|
||
static char f32f64[] = " # f32转换为f64类型\n"
|
||
" fcvt.d.s fa0, fa0";
|
||
static char f32f128[] = " # f32转换为f128类型\n"
|
||
" call __extendsftf2@plt";
|
||
|
||
// 双精度浮点数转换为整型
|
||
static char f64i8[] = " # f64转换为i8类型\n"
|
||
" fcvt.w.d a0, fa0, rtz\n"
|
||
" slli a0, a0, 56\n"
|
||
" srai a0, a0, 56";
|
||
static char f64i16[] = " # f64转换为i16类型\n"
|
||
" fcvt.w.d a0, fa0, rtz\n"
|
||
" slli a0, a0, 48\n"
|
||
" srai a0, a0, 48";
|
||
static char f64i32[] = " # f64转换为i32类型\n"
|
||
" fcvt.w.d a0, fa0, rtz\n"
|
||
" slli a0, a0, 32\n"
|
||
" srai a0, a0, 32";
|
||
static char f64i64[] = " # f64转换为i64类型\n"
|
||
" fcvt.l.d a0, fa0, rtz";
|
||
|
||
// 双精度浮点数转换为无符号整型
|
||
static char f64u8[] = " # f64转换为u8类型\n"
|
||
" fcvt.wu.d a0, fa0, rtz\n"
|
||
" slli a0, a0, 56\n"
|
||
" srli a0, a0, 56";
|
||
static char f64u16[] = " # f64转换为u16类型\n"
|
||
" fcvt.wu.d a0, fa0, rtz\n"
|
||
" slli a0, a0, 48\n"
|
||
" srli a0, a0, 48";
|
||
static char f64u32[] = " # f64转换为u32类型\n"
|
||
" fcvt.wu.d a0, fa0, rtz\n"
|
||
" slli a0, a0, 32\n"
|
||
" srai a0, a0, 32";
|
||
static char f64u64[] = " # f64转换为u64类型\n"
|
||
" fcvt.lu.d a0, fa0, rtz";
|
||
|
||
// 双精度转换为单精度浮点数
|
||
static char f64f32[] = " # f64转换为f32类型\n"
|
||
" fcvt.s.d fa0, fa0";
|
||
|
||
static char f64f128[] = " # f64转换为f128类型\n"
|
||
" call __extenddftf2@plt";
|
||
|
||
// long double转换
|
||
static char f128i8[] = " # f128转换为i8类型\n"
|
||
" call __fixtfsi@plt\n"
|
||
" slli a0, a0, 56\n"
|
||
" srai a0, a0, 56";
|
||
|
||
static char f128i16[] = " # f128转换为i16类型\n"
|
||
" call __fixtfsi@plt\n"
|
||
" slli a0, a0, 48\n"
|
||
" srai a0, a0, 48";
|
||
|
||
static char f128i32[] = " # f128转换为i32类型\n"
|
||
" call __fixtfsi@plt\n"
|
||
" slli a0, a0, 32\n"
|
||
" srai a0, a0, 32";
|
||
|
||
static char f128i64[] = " # f128转换为i64类型\n"
|
||
" call __fixtfdi@plt";
|
||
|
||
static char f128u8[] = " # f128转换为u8类型\n"
|
||
" call __fixunstfsi@plt\n"
|
||
" slli a0, a0, 56\n"
|
||
" srli a0, a0, 56";
|
||
|
||
static char f128u16[] = " # f128转换为u16类型\n"
|
||
" call __fixunstfsi@plt\n"
|
||
" slli a0, a0, 48\n"
|
||
" srli a0, a0, 48";
|
||
|
||
static char f128u32[] = " # f128转换为u32类型\n"
|
||
" call __fixunstfsi@plt\n"
|
||
" slli a0, a0, 32\n"
|
||
" srai a0, a0, 32";
|
||
|
||
static char f128u64[] = " # f128转换为u64类型\n"
|
||
" call __fixunstfdi@plt";
|
||
|
||
static char f128f32[] = " # f128转换为f32类型\n"
|
||
" call __trunctfsf2@plt";
|
||
|
||
static char f128f64[] = " # f128转换为f64类型\n"
|
||
" call __trunctfdf2@plt";
|
||
|
||
// 所有类型转换表
|
||
static char *castTable[11][11] = {
|
||
// clang-format off
|
||
|
||
// 被映射到
|
||
// {i8, i16, i32, i64, u8, u16, u32, u64, f32, f64, f128}
|
||
{NULL, NULL, NULL, NULL, i64u8, i64u16, i64u32, NULL, i32f32, i32f64, i32f128}, // 从i8转换
|
||
{i64i8, NULL, NULL, NULL, i64u8, i64u16, i64u32, NULL, i32f32, i32f64, i32f128}, // 从i16转换
|
||
{i64i8, i64i16, NULL, NULL, i64u8, i64u16, i64u32, NULL, i32f32, i32f64, i32f128}, // 从i32转换
|
||
{i64i8, i64i16, i64i32, NULL, i64u8, i64u16, i64u32, NULL, i64f32, i64f64, i64f128}, // 从i64转换
|
||
|
||
{i64i8, NULL, NULL, NULL, NULL, NULL, NULL, NULL, u32f32, u32f64, u32f128}, // 从u8转换
|
||
{i64i8, i64i16, NULL, NULL, i64u8, NULL, NULL, NULL, u32f32, u32f64, u32f128}, // 从u16转换
|
||
{i64i8, i64i16, i64i32, u32i64, i64u8, i64u16, NULL, u32i64, u32f32, u32f64, u32f128}, // 从u32转换
|
||
{i64i8, i64i16, i64i32, NULL, i64u8, i64u16, i64u32, NULL, u64f32, u64f64, u64f128}, // 从u64转换
|
||
|
||
{f32i8, f32i16, f32i32, f32i64, f32u8, f32u16, f32u32, f32u64, NULL, f32f64, f32f128}, // 从f32转换
|
||
{f64i8, f64i16, f64i32, f64i64, f64u8, f64u16, f64u32, f64u64, f64f32, NULL, f64f128}, // 从f64转换
|
||
{f128i8, f128i16, f128i32, f128i64, f128u8, f128u16, f128u32, f128u64, f128f32, f128f64, NULL}, // 从f128转换
|
||
|
||
// clang-format on
|
||
};
|
||
|
||
// 类型转换
|
||
static void cast(Type *From, Type *To) {
|
||
if (To->Kind == TY_VOID)
|
||
return;
|
||
|
||
if (To->Kind == TY_BOOL) {
|
||
notZero(From);
|
||
printLn(" # 转为bool类型：为0置0，非0置1");
|
||
printLn(" snez a0, a0");
|
||
return;
|
||
}
|
||
|
||
// 获取类型的枚举值
|
||
int T1 = getTypeId(From);
|
||
int T2 = getTypeId(To);
|
||
if (castTable[T1][T2]) {
|
||
printLn(" # 转换函数");
|
||
if (T1 == F128)
|
||
popLD(0);
|
||
printLn("%s", castTable[T1][T2]);
|
||
if (T2 == F128)
|
||
pushLD();
|
||
}
|
||
}
|
||
|
||
// 获取浮点结构体的成员类型
|
||
void getFloStMemsTy(Type *Ty, Type **RegsTy, int *Idx) {
|
||
switch (Ty->Kind) {
|
||
case TY_STRUCT:
|
||
// 遍历结构体的成员，获取成员类型
|
||
for (Member *Mem = Ty->Mems; Mem; Mem = Mem->Next)
|
||
getFloStMemsTy(Mem->Ty, RegsTy, Idx);
|
||
return;
|
||
case TY_UNION:
|
||
// 含有联合体不是浮点结构体
|
||
*Idx += 2;
|
||
return;
|
||
case TY_LDOUBLE:
|
||
// long double不是浮点结构体
|
||
*Idx += 2;
|
||
return;
|
||
case TY_ARRAY:
|
||
// 遍历数组的成员，计算是否为浮点结构体
|
||
for (int I = 0; I < Ty->ArrayLen; ++I)
|
||
getFloStMemsTy(Ty->Base, RegsTy, Idx);
|
||
return;
|
||
default:
|
||
// 若为基础类型，且存在可用寄存器时，填充成员的类型
|
||
if (*Idx < 2)
|
||
RegsTy[*Idx] = Ty;
|
||
*Idx += 1;
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 是否为一或两个含浮点成员变量的结构体
|
||
void setFloStMemsTy(Type **Ty, int GP, int FP) {
|
||
Type *T = *Ty;
|
||
T->FSReg1Ty = TyVoid;
|
||
T->FSReg2Ty = TyVoid;
|
||
|
||
// 联合体不通过浮点寄存器传递
|
||
if (T->Kind == TY_UNION)
|
||
return;
|
||
|
||
// RTy：RegsType，结构体的第一、二个寄存器的类型
|
||
Type *RTy[2] = {TyVoid, TyVoid};
|
||
// 记录可以使用的寄存器的索引值
|
||
int RegsTyIdx = 0;
|
||
// 获取浮点结构体的寄存器类型，如果不是则为TyVoid
|
||
getFloStMemsTy(T, RTy, &RegsTyIdx);
|
||
|
||
// 不是浮点结构体，直接退出
|
||
if (RegsTyIdx > 2)
|
||
return;
|
||
|
||
if ( // 只有一个浮点成员的结构体，使用1个FP
|
||
(isSFloNum(RTy[0]) && RTy[1] == TyVoid && FP < FP_MAX) ||
|
||
// 一个浮点成员和一个整型成员的结构体，使用1个FP和1个GP
|
||
(isSFloNum(RTy[0]) && isInteger(RTy[1]) && FP < FP_MAX && GP < GP_MAX) ||
|
||
(isInteger(RTy[0]) && isSFloNum(RTy[1]) && FP < FP_MAX && GP < GP_MAX) ||
|
||
// 两个浮点成员的结构体，使用2个FP
|
||
(isSFloNum(RTy[0]) && isSFloNum(RTy[1]) && FP + 1 < FP_MAX)) {
|
||
T->FSReg1Ty = RTy[0];
|
||
T->FSReg2Ty = RTy[1];
|
||
}
|
||
}
|
||
|
||
// 为大结构体开辟空间
|
||
static int createBSSpace(Node *Args) {
|
||
int BSStack = 0;
|
||
for (Node *Arg = Args; Arg; Arg = Arg->Next) {
|
||
Type *Ty = Arg->Ty;
|
||
// 大于16字节的结构体
|
||
if (Ty->Size > 16 && Ty->Kind == TY_STRUCT) {
|
||
printLn(" # 大于16字节的结构体，先开辟相应的栈空间");
|
||
int Sz = alignTo(Ty->Size, 8);
|
||
printLn(" addi sp, sp, -%d", Sz);
|
||
// t6指向了最终的 大结构体空间的起始位置
|
||
printLn(" mv t6, sp");
|
||
Depth += Sz / 8;
|
||
BSStack += Sz / 8;
|
||
BSDepth += Sz / 8;
|
||
}
|
||
}
|
||
return BSStack;
|
||
}
|
||
|
||
// 传递结构体的指针
|
||
static void pushStruct(Type *Ty) {
|
||
// 大于16字节的结构体
|
||
if (Ty->Size > 16) {
|
||
// 将结构体复制一份到栈中，然后通过寄存器或栈传递被复制结构体的地址
|
||
// ---------------------------------
|
||
// 大结构体 ←
|
||
// --------------------------------- <- t6
|
||
// 栈传递的 其他变量
|
||
// ---------------------------------
|
||
// 大结构体的指针 ↑
|
||
// --------------------------------- <- sp
|
||
|
||
// 计算大结构体的偏移量
|
||
int Sz = alignTo(Ty->Size, 8);
|
||
// BSDepth记录了剩余 大结构体的字节数
|
||
BSDepth -= Sz / 8;
|
||
// t6存储了，大结构体空间的起始位置
|
||
int BSOffset = BSDepth * 8;
|
||
|
||
printLn(" # 复制%d字节的大结构体到%d(t6)的位置", Sz, BSOffset);
|
||
for (int I = 0; I < Sz; I++) {
|
||
printLn(" lb t0, %d(a0)", I);
|
||
printLn(" sb t0, %d(t6)", BSOffset + I);
|
||
}
|
||
|
||
printLn(" # 大于16字节的结构体，对该结构体地址压栈");
|
||
printLn(" addi a0, t6, %d", BSOffset);
|
||
push();
|
||
return;
|
||
}
|
||
|
||
// 含有两个成员（含浮点）的结构体
|
||
// 展开到栈内的两个8字节的空间
|
||
if ((isSFloNum(Ty->FSReg1Ty) && Ty->FSReg2Ty != TyVoid) ||
|
||
isSFloNum(Ty->FSReg2Ty)) {
|
||
printLn(" # 对含有两个成员（含浮点）结构体进行压栈");
|
||
printLn(" addi sp, sp, -16");
|
||
Depth += 2;
|
||
|
||
printLn(" ld t0, 0(a0)");
|
||
printLn(" sd t0, 0(sp)");
|
||
|
||
// 计算第二部分在结构体中的偏移量，为两个成员间的最大尺寸
|
||
int Off = MAX(Ty->FSReg1Ty->Size, Ty->FSReg2Ty->Size);
|
||
printLn(" ld t0, %d(a0)", Off);
|
||
printLn(" sd t0, 8(sp)");
|
||
|
||
return;
|
||
}
|
||
// 处理只有一个浮点成员的结构体
|
||
// 或者是小于16字节的结构体
|
||
char *Str = isSFloNum(Ty->FSReg1Ty) ? "只有一个浮点" : "小于16字节";
|
||
int Sz = alignTo(Ty->Size, 8);
|
||
printLn(" # 为%s的结构体开辟%d字节的空间，", Str, Sz);
|
||
printLn(" addi sp, sp, -%d", Sz);
|
||
Depth += Sz / 8;
|
||
|
||
printLn(" # 开辟%d字节的空间，复制%s的内存", Sz, Str);
|
||
for (int I = 0; I < Ty->Size; I++) {
|
||
printLn(" lb t0, %d(a0)", I);
|
||
printLn(" sb t0, %d(sp)", I);
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 将函数实参计算后压入栈中
|
||
static void pushArgs2(Node *Args, bool FirstPass) {
|
||
// 参数为空直接返回
|
||
if (!Args)
|
||
return;
|
||
|
||
// 递归到最后一个实参进行
|
||
pushArgs2(Args->Next, FirstPass);
|
||
|
||
// 第一遍对栈传递的变量进行压栈
|
||
// 第二遍对寄存器传递的变量进行压栈
|
||
if ((FirstPass && !Args->PassByStack) ||
|
||
(!FirstPass && Args->PassByStack))
|
||
return;
|
||
|
||
printLn("\n # ↓对表达式进行计算，然后压栈↓");
|
||
// 计算出表达式
|
||
genExpr(Args);
|
||
// 根据表达式结果的类型进行压栈
|
||
switch (Args->Ty->Kind) {
|
||
case TY_STRUCT:
|
||
case TY_UNION:
|
||
pushStruct(Args->Ty);
|
||
break;
|
||
case TY_FLOAT:
|
||
case TY_DOUBLE:
|
||
pushF();
|
||
break;
|
||
case TY_LDOUBLE:
|
||
printLn(" # 对long double参数表达式进行计算后压栈");
|
||
LDSP -= 2;
|
||
printLn(" addi sp, sp, -16");
|
||
printLn(" fsd fs%d, 8(sp)", LDSP + 1);
|
||
printLn(" fsd fs%d, 0(sp)", LDSP);
|
||
Depth += 2;
|
||
break;
|
||
default:
|
||
push();
|
||
}
|
||
printLn(" # ↑结束压栈↑");
|
||
}
|
||
|
||
// 处理参数后进行压栈
|
||
static int pushArgs(Node *Nd) {
|
||
int Stack = 0, GP = 0, FP = 0;
|
||
|
||
// 如果是超过16字节的结构体，则通过第一个寄存器传递结构体的指针
|
||
if (Nd->RetBuffer && Nd->Ty->Size > 16)
|
||
GP++;
|
||
|
||
// 遍历所有参数，优先使用寄存器传递，然后是栈传递
|
||
Type *CurArg = Nd->FuncType->Params;
|
||
for (Node *Arg = Nd->Args; Arg; Arg = Arg->Next) {
|
||
// 如果是可变参数的参数，只使用整型寄存器和栈传递
|
||
if (Nd->FuncType->IsVariadic && CurArg == NULL) {
|
||
int64_t Val = Arg->Val ? Arg->Val : Arg->FVal;
|
||
if (GP < GP_MAX) {
|
||
printLn(" # 可变参数%ld值通过a%d传递", Val, GP);
|
||
GP++;
|
||
} else {
|
||
printLn(" # 可变参数%ld值通过栈传递", Val);
|
||
Arg->PassByStack = true;
|
||
Stack++;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// 遍历相应的实参，用于检查是不是到了可变参数
|
||
CurArg = CurArg->Next;
|
||
|
||
// 读取实参的类型
|
||
Type *Ty = Arg->Ty;
|
||
|
||
switch (Ty->Kind) {
|
||
case TY_STRUCT:
|
||
case TY_UNION: {
|
||
// 判断结构体的类型
|
||
setFloStMemsTy(&Ty, GP, FP);
|
||
// 处理一或两个浮点成员变量的结构体
|
||
if (isSFloNum(Ty->FSReg1Ty) || isSFloNum(Ty->FSReg2Ty)) {
|
||
Type *Regs[2] = {Ty->FSReg1Ty, Ty->FSReg2Ty};
|
||
for (int I = 0; I < 2; ++I) {
|
||
if (isSFloNum(Regs[I]))
|
||
FP++;
|
||
if (isInteger(Regs[I]))
|
||
GP++;
|
||
}
|
||
break;
|
||
}
|
||
|
||
// 9~16字节整型结构体用两个寄存器，其他字节结构体用一个寄存器
|
||
int Regs = (8 < Ty->Size && Ty->Size <= 16) ? 2 : 1;
|
||
for (int I = 1; I <= Regs; ++I) {
|
||
if (GP < GP_MAX) {
|
||
GP++;
|
||
} else {
|
||
Arg->PassByStack = true;
|
||
Stack++;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case TY_FLOAT:
|
||
case TY_DOUBLE:
|
||
// 浮点优先使用FP，而后是GP，最后是栈传递
|
||
if (FP < FP_MAX) {
|
||
printLn(" # 浮点%Lf值通过fa%d传递", Arg->FVal, FP);
|
||
FP++;
|
||
} else if (GP < GP_MAX) {
|
||
printLn(" # 浮点%Lf值通过a%d传递", Arg->FVal, GP);
|
||
GP++;
|
||
} else {
|
||
printLn(" # 浮点%Lf值通过栈传递", Arg->FVal);
|
||
Arg->PassByStack = true;
|
||
Stack++;
|
||
}
|
||
break;
|
||
case TY_LDOUBLE:
|
||
for (int I = 1; I <= 2; ++I) {
|
||
if (GP < GP_MAX) {
|
||
printLn(" # LD的第%d部分%Lf值通过a%d传递", I, Arg->FVal, GP);
|
||
GP++;
|
||
} else {
|
||
printLn(" # LD的第%d部分%Lf值通过栈传递", I, Arg->FVal);
|
||
Stack++;
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
// 整型优先使用GP，最后是栈传递
|
||
if (GP < GP_MAX) {
|
||
printLn(" # 整型%ld值通过a%d传递", Arg->Val, GP);
|
||
GP++;
|
||
} else {
|
||
printLn(" # 整型%ld值通过栈传递", Arg->Val);
|
||
Arg->PassByStack = true;
|
||
Stack++;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 对齐栈边界
|
||
if ((Depth + Stack) % 2 == 1) {
|
||
printLn(" # 对齐栈边界到16字节");
|
||
printLn(" addi sp, sp, -8");
|
||
Depth++;
|
||
Stack++;
|
||
}
|
||
|
||
// 进行压栈
|
||
// 开辟大于16字节的结构体的栈空间
|
||
int BSStack = createBSSpace(Nd->Args);
|
||
// 第一遍对栈传递的变量进行压栈
|
||
pushArgs2(Nd->Args, true);
|
||
// 第二遍对寄存器传递的变量进行压栈
|
||
pushArgs2(Nd->Args, false);
|
||
// 返回栈传递参数的个数
|
||
|
||
if (Nd->RetBuffer && Nd->Ty->Size > 16) {
|
||
printLn(" # 返回类型是大于16字节的结构体，指向其的指针，压入栈顶");
|
||
printLn(" li t0, %d", Nd->RetBuffer->Offset);
|
||
printLn(" add a0, fp, t0");
|
||
push();
|
||
}
|
||
|
||
return Stack + BSStack;
|
||
}
|
||
|
||
// 复制结构体返回值到缓冲区中
|
||
static void copyRetBuffer(Obj *Var) {
|
||
Type *Ty = Var->Ty;
|
||
int GP = 0, FP = 0;
|
||
|
||
setFloStMemsTy(&Ty, GP, FP);
|
||
|
||
printLn(" # 拷贝到返回缓冲区");
|
||
printLn(" # 加载struct地址到t0");
|
||
printLn(" li t0, %d", Var->Offset);
|
||
printLn(" add t1, fp, t0");
|
||
|
||
// 处理浮点结构体的情况
|
||
if (isSFloNum(Ty->FSReg1Ty) || isSFloNum(Ty->FSReg2Ty)) {
|
||
int Off = 0;
|
||
Type *RTys[2] = {Ty->FSReg1Ty, Ty->FSReg2Ty};
|
||
for (int I = 0; I < 2; ++I) {
|
||
switch (RTys[I]->Kind) {
|
||
case TY_FLOAT:
|
||
printLn(" fsw fa%d, %d(t1)", FP++, Off);
|
||
Off = 4;
|
||
break;
|
||
case TY_DOUBLE:
|
||
printLn(" fsd fa%d, %d(t1)", FP++, Off);
|
||
Off = 8;
|
||
break;
|
||
case TY_VOID:
|
||
break;
|
||
default:
|
||
printLn(" sd a%d, %d(t1)", GP++, Off);
|
||
Off = 8;
|
||
break;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
printLn(" # 复制整型结构体返回值到缓冲区中");
|
||
for (int Off = 0; Off < Ty->Size; Off += 8) {
|
||
switch (Ty->Size - Off) {
|
||
case 1:
|
||
printLn(" sb a%d, %d(t1)", GP++, Off);
|
||
break;
|
||
case 2:
|
||
printLn(" sh a%d, %d(t1)", GP++, Off);
|
||
break;
|
||
case 3:
|
||
case 4:
|
||
printLn(" sw a%d, %d(t1)", GP++, Off);
|
||
break;
|
||
default:
|
||
printLn(" sd a%d, %d(t1)", GP++, Off);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 拷贝结构体的寄存器
|
||
static void copyStructReg(void) {
|
||
Type *Ty = CurrentFn->Ty->ReturnTy;
|
||
int GP = 0, FP = 0;
|
||
|
||
printLn(" # 复制结构体寄存器");
|
||
printLn(" # 读取寄存器，写入存有struct地址的0(t1)中");
|
||
printLn(" mv t1, a0");
|
||
|
||
setFloStMemsTy(&Ty, GP, FP);
|
||
|
||
if (isSFloNum(Ty->FSReg1Ty) || isSFloNum(Ty->FSReg2Ty)) {
|
||
int Off = 0;
|
||
Type *RTys[2] = {Ty->FSReg1Ty, Ty->FSReg2Ty};
|
||
for (int I = 0; I < 2; ++I) {
|
||
switch (RTys[I]->Kind) {
|
||
case TY_FLOAT:
|
||
printLn(" flw fa%d, %d(t1)", FP++, Off);
|
||
Off = 4;
|
||
break;
|
||
case TY_DOUBLE:
|
||
printLn(" fld fa%d, %d(t1)", FP++, Off);
|
||
Off = 8;
|
||
break;
|
||
case TY_VOID:
|
||
break;
|
||
default:
|
||
printLn(" ld a%d, %d(t1)", GP++, Off);
|
||
Off = 8;
|
||
break;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
printLn(" # 复制返回的整型结构体的值");
|
||
for (int Off = 0; Off < Ty->Size; Off += 8) {
|
||
switch (Ty->Size - Off) {
|
||
case 1:
|
||
printLn(" lb a%d, %d(t1)", GP++, Off);
|
||
break;
|
||
case 2:
|
||
printLn(" lh a%d, %d(t1)", GP++, Off);
|
||
break;
|
||
case 3:
|
||
case 4:
|
||
printLn(" lw a%d, %d(t1)", GP++, Off);
|
||
break;
|
||
default:
|
||
printLn(" ld a%d, %d(t1)", GP++, Off);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 大于16字节的结构体返回值，需要拷贝内存
|
||
static void copyStructMem(void) {
|
||
Type *Ty = CurrentFn->Ty->ReturnTy;
|
||
// 第一个参数，调用者的缓冲区指针
|
||
Obj *Var = CurrentFn->Params;
|
||
|
||
printLn(" # 复制大于16字节结构体内存");
|
||
printLn(" # 将栈内struct地址存入t1，调用者的结构体的地址");
|
||
printLn(" li t0, %d", Var->Offset);
|
||
printLn(" add t0, fp, t0");
|
||
printLn(" ld t1, 0(t0)");
|
||
|
||
printLn(" # 遍历结构体并从a0位置复制所有字节到t1");
|
||
for (int I = 0; I < Ty->Size; I++) {
|
||
printLn(" lb t0, %d(a0)", I);
|
||
printLn(" sb t0, %d(t1)", I);
|
||
}
|
||
}
|
||
|
||
// 开辟Alloca空间
|
||
static void builtinAlloca(void) {
|
||
// 对齐需要的空间t1到16字节
|
||
//
|
||
// 加上15，然后去除最低位的十六进制数
|
||
printLn(" addi t1, t1, 15");
|
||
printLn(" andi t1, t1, -16");
|
||
|
||
// 注意t2与t1大小不定，仅为示例
|
||
// ----------------------------- 旧sp（AllocaBottom所存的sp）
|
||
// - - - - - - - - - - - - - - -
|
||
// 需要在此开辟大小为t1的Alloca区域
|
||
// - - - - - - - - - - - - - - -
|
||
// ↑
|
||
// t2（旧sp和新sp间的距离）
|
||
// ↓
|
||
// ----------------------------- 新sp ← sp
|
||
|
||
// 根据t1的值，提升临时区域
|
||
//
|
||
// 加载 旧sp 到t2中
|
||
printLn(" li t0, %d", CurrentFn->AllocaBottom->Offset);
|
||
printLn(" add t0, fp, t0");
|
||
printLn(" ld t2, 0(t0)");
|
||
// t2=旧sp-新sp，将二者的距离存入t2
|
||
printLn(" sub t2, t2, sp");
|
||
|
||
// 保存 新sp 存入a0
|
||
printLn(" mv a0, sp");
|
||
// 新sp 开辟（减去）所需要的空间数，结果存入 sp
|
||
// 并将 新sp开辟空间后的栈顶 同时存入t3
|
||
printLn(" sub sp, sp, t1");
|
||
printLn(" mv t3, sp");
|
||
|
||
// 注意t2与t1大小不定，仅为示例
|
||
// ----------------------------- 旧sp（AllocaBottom所存的sp）
|
||
// ↑
|
||
// t2（旧sp和新sp间的距离）
|
||
// ↓
|
||
// ----------------------------- 新sp ← a0
|
||
// ↑
|
||
// t1（Alloca所需要的空间数）
|
||
// ↓
|
||
// ----------------------------- 新新sp ← sp,t3
|
||
|
||
// 将 新sp内（底部和顶部间的）数据，复制到 新sp的顶部之上
|
||
printLn("1:");
|
||
// t2为0时跳转到标签2，结束复制
|
||
printLn("beqz t2, 2f");
|
||
// 将 新sp底部 内容复制到 新sp顶部之上
|
||
printLn(" lb t0, 0(a0)");
|
||
printLn(" sb t0, 0(t3)");
|
||
printLn(" addi a0, a0, 1");
|
||
printLn(" addi t3, t3, 1");
|
||
printLn(" addi t2, t2, -1");
|
||
printLn(" j 1b");
|
||
printLn("2:");
|
||
|
||
// 注意t2与t1大小不定，仅为示例
|
||
// ------------------------------ 旧sp a0
|
||
// ↑ ↓
|
||
// t1（Alloca区域）
|
||
// ↓
|
||
// ------------------------------ 新sp ← a0
|
||
// ↑
|
||
// t2（旧sp和新sp间的内容，复制到此）
|
||
// ↓
|
||
// ------------------------------ 新新sp ← sp
|
||
|
||
// 移动alloca_bottom指针
|
||
//
|
||
// 加载 旧sp 到 a0
|
||
printLn(" li t0, %d", CurrentFn->AllocaBottom->Offset);
|
||
printLn(" add t0, fp, t0");
|
||
printLn(" ld a0, 0(t0)");
|
||
// 旧sp 减去开辟的空间 t1
|
||
printLn(" sub a0, a0, t1");
|
||
// 存储a0到alloca底部地址
|
||
printLn("sd a0, 0(t0)");
|
||
}
|
||
|
||
// 生成表达式
|
||
static void genExpr(Node *Nd) {
|
||
// .loc 文件编号 行号
|
||
printLn(" .loc %d %d", Nd->Tok->File->FileNo, Nd->Tok->LineNo);
|
||
|
||
// 生成各个根节点
|
||
switch (Nd->Kind) {
|
||
// 空表达式
|
||
case ND_NULL_EXPR:
|
||
return;
|
||
// 加载数字到a0
|
||
|
||
// float和uint32、double和uint64 共用一份内存空间
|
||
case ND_NUM: {
|
||
switch (Nd->Ty->Kind) {
|
||
case TY_FLOAT: {
|
||
union {
|
||
float F32;
|
||
uint32_t U32;
|
||
} U;
|
||
U.F32 = Nd->FVal;
|
||
printLn(" # 将a0转换到float类型值为%Lf的fa0中", Nd->FVal);
|
||
printLn(" li a0, %u # float %Lf", U.U32, Nd->FVal);
|
||
printLn(" fmv.w.x fa0, a0");
|
||
return;
|
||
}
|
||
case TY_DOUBLE: {
|
||
union {
|
||
double F64;
|
||
uint64_t U64;
|
||
} U;
|
||
printLn(" # 将a0转换到double类型值为%Lf的fa0中", Nd->FVal);
|
||
U.F64 = Nd->FVal;
|
||
printLn(" li a0, %lu # double %Lf", U.U64, Nd->FVal);
|
||
printLn(" fmv.d.x fa0, a0");
|
||
return;
|
||
}
|
||
case TY_LDOUBLE: {
|
||
#ifdef __riscv
|
||
union {
|
||
long double F128;
|
||
uint64_t U64[2];
|
||
} U;
|
||
memset(&U, 0, sizeof(U));
|
||
U.F128 = Nd->FVal;
|
||
printLn(" # 将long double类型的%Lf值，压入LD栈中", Nd->FVal);
|
||
printLn(" li a0, 0x%016lx # long double %Lf", U.U64[0], Nd->FVal);
|
||
printLn(" fmv.d.x fs%d, a0", LDSP);
|
||
|
||
printLn(" li a0, 0x%016lx", U.U64[1]);
|
||
printLn(" fmv.d.x fs%d, a0", LDSP + 1);
|
||
LDSP += 2;
|
||
return;
|
||
#endif // __riscv
|
||
#ifdef __x86_64
|
||
// 【注意】交叉环境当中，x86_64的long double是f80而非f128
|
||
// 因而此处的支持仅供交叉测试，存在f80->f64的精度的丢失！
|
||
union {
|
||
double F64;
|
||
uint64_t U64;
|
||
} U = {Nd->FVal};
|
||
printLn(" # 【注意】此处存在f80->f64的精度丢失！！！");
|
||
printLn(" # 将long double类型的%Lf值，压入LD栈中", Nd->FVal);
|
||
printLn(" li a0, %lu # double %Lf", U.U64, Nd->FVal);
|
||
printLn(" fmv.d.x fa0, a0");
|
||
printLn(" call __extenddftf2@plt");
|
||
pushLD();
|
||
return;
|
||
#endif // __x86_64
|
||
}
|
||
default:
|
||
printLn(" # 将%ld加载到a0中", Nd->Val);
|
||
printLn(" li a0, %ld", Nd->Val);
|
||
return;
|
||
}
|
||
}
|
||
// 对寄存器取反
|
||
case ND_NEG:
|
||
// 计算左部的表达式
|
||
genExpr(Nd->LHS);
|
||
|
||
switch (Nd->Ty->Kind) {
|
||
case TY_FLOAT:
|
||
printLn(" # 对float类型的fa0值进行取反");
|
||
printLn(" fneg.s fa0, fa0");
|
||
return;
|
||
case TY_DOUBLE:
|
||
printLn(" # 对double类型的fa0值进行取反");
|
||
printLn(" fneg.d fa0, fa0");
|
||
return;
|
||
case TY_LDOUBLE:
|
||
printLn(" # 对long double类型的LD栈顶值进行取反");
|
||
printLn(" li t0, -1");
|
||
printLn(" slli t0, t0, 63");
|
||
printLn(" xor a%d, a%d, t0", LDSP + 1, LDSP + 1);
|
||
return;
|
||
default:
|
||
// neg a0, a0是sub a0, x0, a0的别名, 即a0=0-a0
|
||
printLn(" # 对a0值进行取反");
|
||
printLn(" neg%s a0, a0", Nd->Ty->Size <= 4 ? "w" : "");
|
||
return;
|
||
}
|
||
// 变量
|
||
case ND_VAR:
|
||
// 计算出变量的地址，然后存入a0
|
||
genAddr(Nd);
|
||
load(Nd->Ty);
|
||
return;
|
||
// 成员变量
|
||
case ND_MEMBER: {
|
||
// 计算出成员变量的地址，然后存入a0
|
||
genAddr(Nd);
|
||
load(Nd->Ty);
|
||
|
||
Member *Mem = Nd->Mem;
|
||
if (Mem->IsBitfield) {
|
||
printLn(" # 清除位域的成员变量（%d位）未用到的位", Mem->BitWidth);
|
||
// 清除位域成员变量未用到的高位
|
||
printLn(" slli a0, a0, %d", 64 - Mem->BitWidth - Mem->BitOffset);
|
||
// 清除位域成员变量未用到的低位
|
||
if (Mem->Ty->IsUnsigned)
|
||
printLn(" srli a0, a0, %d", 64 - Mem->BitWidth);
|
||
else
|
||
printLn(" srai a0, a0, %d", 64 - Mem->BitWidth);
|
||
}
|
||
return;
|
||
}
|
||
// 解引用
|
||
case ND_DEREF:
|
||
genExpr(Nd->LHS);
|
||
load(Nd->Ty);
|
||
return;
|
||
// 取地址
|
||
case ND_ADDR:
|
||
genAddr(Nd->LHS);
|
||
return;
|
||
// 赋值
|
||
case ND_ASSIGN:
|
||
// 左部是左值，保存值到的地址
|
||
genAddr(Nd->LHS);
|
||
push();
|
||
// 右部是右值，为表达式的值
|
||
genExpr(Nd->RHS);
|
||
|
||
// 如果是位域成员变量，需要先从内存中读取当前值，然后合并到新值中
|
||
if (Nd->LHS->Kind == ND_MEMBER && Nd->LHS->Mem->IsBitfield) {
|
||
printLn("\n # 位域成员变量进行赋值↓");
|
||
printLn(" # 备份需要赋的a0值");
|
||
printLn(" mv t2, a0");
|
||
|
||
printLn(" # 计算位域成员变量的新值：");
|
||
Member *Mem = Nd->LHS->Mem;
|
||
// 将需要赋的值a0存入t1
|
||
printLn(" mv t1, a0");
|
||
// 构造一个和位域成员长度相同，全为1的二进制数
|
||
printLn(" li t0, %ld", (1L << Mem->BitWidth) - 1);
|
||
// 取交之后，位域长度的低位，存储了我们需要的值，其他位都为0
|
||
printLn(" and t1, t1, t0");
|
||
// 然后将该值左移，相应的位偏移量中
|
||
// 此时我们所需要的位域数值已经处于正确的位置，且其他位置都为0
|
||
printLn(" slli t1, t1, %d", Mem->BitOffset);
|
||
|
||
printLn(" # 读取位域当前值：");
|
||
// 将位域值保存的地址加载进来
|
||
printLn(" ld a0, 0(sp)");
|
||
// 读取该地址的值
|
||
load(Mem->Ty);
|
||
|
||
printLn(" # 写入成员变量新值到位域当前值中：");
|
||
// 位域值对应的掩码，即t1需要写入的位置
|
||
// 掩码位都为1，其余位为0
|
||
long Mask = ((1L << Mem->BitWidth) - 1) << Mem->BitOffset;
|
||
// 对掩码取反，此时，其余位都为1，掩码位都为0
|
||
printLn(" li t0, %ld", ~Mask);
|
||
// 取交，保留除掩码位外所有的位
|
||
printLn(" and a0, a0, t0");
|
||
// 取或，将成员变量的新值写入到掩码位
|
||
printLn(" or a0, a0, t1");
|
||
|
||
store(Nd->Ty);
|
||
printLn(" # 恢复需要赋的a0值作为返回值");
|
||
printLn(" mv a0, t2");
|
||
printLn(" # 完成位域成员变量的赋值↑\n");
|
||
return;
|
||
}
|
||
|
||
store(Nd->Ty);
|
||
return;
|
||
// 语句表达式
|
||
case ND_STMT_EXPR:
|
||
for (Node *N = Nd->Body; N; N = N->Next)
|
||
genStmt(N);
|
||
return;
|
||
// 逗号
|
||
case ND_COMMA:
|
||
genExpr(Nd->LHS);
|
||
genExpr(Nd->RHS);
|
||
return;
|
||
// 类型转换
|
||
case ND_CAST:
|
||
genExpr(Nd->LHS);
|
||
cast(Nd->LHS->Ty, Nd->Ty);
|
||
return;
|
||
// 内存清零
|
||
case ND_MEMZERO: {
|
||
printLn(" # 对%s的内存%d(fp)清零%d位", Nd->Var->Name, Nd->Var->Offset,
|
||
Nd->Var->Ty->Size);
|
||
// 对栈内变量所占用的每个字节都进行清零
|
||
for (int I = 0; I < Nd->Var->Ty->Size; I++) {
|
||
printLn(" li t0, %d", Nd->Var->Offset + I);
|
||
printLn(" add t0, fp, t0");
|
||
printLn(" sb zero, 0(t0)");
|
||
}
|
||
return;
|
||
}
|
||
// 条件运算符
|
||
case ND_COND: {
|
||
int C = count();
|
||
printLn("\n# =====条件运算符%d===========", C);
|
||
genExpr(Nd->Cond);
|
||
notZero(Nd->Cond->Ty);
|
||
printLn(" # 条件判断，为0则跳转");
|
||
printLn(" beqz a0, .L.else.%d", C);
|
||
genExpr(Nd->Then);
|
||
printLn(" # 跳转到条件运算符结尾部分");
|
||
printLn(" j .L.end.%d", C);
|
||
printLn(".L.else.%d:", C);
|
||
genExpr(Nd->Els);
|
||
printLn(".L.end.%d:", C);
|
||
return;
|
||
}
|
||
// 非运算
|
||
case ND_NOT:
|
||
genExpr(Nd->LHS);
|
||
notZero(Nd->LHS->Ty);
|
||
printLn(" # 非运算");
|
||
// a0=0则置1，否则为0
|
||
printLn(" seqz a0, a0");
|
||
return;
|
||
// 逻辑与
|
||
case ND_LOGAND: {
|
||
int C = count();
|
||
printLn("\n# =====逻辑与%d===============", C);
|
||
genExpr(Nd->LHS);
|
||
// 判断是否为短路操作
|
||
notZero(Nd->LHS->Ty);
|
||
printLn(" # 左部短路操作判断，为0则跳转");
|
||
printLn(" beqz a0, .L.false.%d", C);
|
||
genExpr(Nd->RHS);
|
||
notZero(Nd->RHS->Ty);
|
||
printLn(" # 右部判断，为0则跳转");
|
||
printLn(" beqz a0, .L.false.%d", C);
|
||
printLn(" li a0, 1");
|
||
printLn(" j .L.end.%d", C);
|
||
printLn(".L.false.%d:", C);
|
||
printLn(" li a0, 0");
|
||
printLn(".L.end.%d:", C);
|
||
return;
|
||
}
|
||
// 逻辑或
|
||
case ND_LOGOR: {
|
||
int C = count();
|
||
printLn("\n# =====逻辑或%d===============", C);
|
||
genExpr(Nd->LHS);
|
||
notZero(Nd->LHS->Ty);
|
||
// 判断是否为短路操作
|
||
printLn(" # 左部短路操作判断，不为0则跳转");
|
||
printLn(" bnez a0, .L.true.%d", C);
|
||
genExpr(Nd->RHS);
|
||
notZero(Nd->RHS->Ty);
|
||
printLn(" # 右部判断，不为0则跳转");
|
||
printLn(" bnez a0, .L.true.%d", C);
|
||
printLn(" li a0, 0");
|
||
printLn(" j .L.end.%d", C);
|
||
printLn(".L.true.%d:", C);
|
||
printLn(" li a0, 1");
|
||
printLn(".L.end.%d:", C);
|
||
return;
|
||
}
|
||
// 按位取非运算
|
||
case ND_BITNOT:
|
||
genExpr(Nd->LHS);
|
||
printLn(" # 按位取反");
|
||
// 这里的 not a0, a0 为 xori a0, a0, -1 的伪码
|
||
printLn(" not a0, a0");
|
||
return;
|
||
// 函数调用
|
||
case ND_FUNCALL: {
|
||
// 对alloca函数进行处理
|
||
if (Nd->LHS->Kind == ND_VAR && !strcmp(Nd->LHS->Var->Name, "alloca")) {
|
||
// 解析alloca函数的参数，确定开辟空间的字节数
|
||
genExpr(Nd->Args);
|
||
// 将需要的字节数存入t1
|
||
printLn(" mv t1, a0");
|
||
// 生成Alloca函数汇编
|
||
builtinAlloca();
|
||
return;
|
||
}
|
||
|
||
// 计算所有参数的值，正向压栈
|
||
// 此处获取到栈传递参数的数量
|
||
int StackArgs = pushArgs(Nd);
|
||
genExpr(Nd->LHS);
|
||
// 将a0的值存入t5
|
||
printLn(" mv t5, a0");
|
||
|
||
// 反向弹栈，a0->参数1，a1->参数2……
|
||
int GP = 0, FP = 0;
|
||
|
||
if (Nd->RetBuffer && Nd->Ty->Size > 16) {
|
||
printLn(" # 返回结构体大于16字节，那么第一个参数指向返回缓冲区");
|
||
pop(GP++);
|
||
}
|
||
|
||
// 读取函数形参中的参数类型
|
||
Type *CurArg = Nd->FuncType->Params;
|
||
for (Node *Arg = Nd->Args; Arg; Arg = Arg->Next) {
|
||
// 如果是可变参数函数
|
||
// 匹配到空参数（最后一个）的时候，将剩余的整型寄存器弹栈
|
||
if (Nd->FuncType->IsVariadic && CurArg == NULL) {
|
||
if (GP < GP_MAX) {
|
||
if (Arg->Ty->Kind == TY_LDOUBLE) {
|
||
// 在可变参数函数的调用中
|
||
// LD的第一个寄存器必须是偶数下标，即a0,a2,a4,a6
|
||
if (GP % 2 == 1)
|
||
GP++;
|
||
printLn(" # long double通过a%d,a%d传递可变实参", GP, GP + 1);
|
||
pop(GP++);
|
||
if (GP < GP_MAX)
|
||
pop(GP++);
|
||
} else {
|
||
printLn(" # a%d传递可变实参", GP);
|
||
pop(GP++);
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
|
||
CurArg = CurArg->Next;
|
||
// 实参的类型
|
||
Type *Ty = Arg->Ty;
|
||
|
||
switch (Ty->Kind) {
|
||
case TY_STRUCT:
|
||
case TY_UNION: {
|
||
// 判断结构体的类型
|
||
// 结构体的大小
|
||
int Sz = Ty->Size;
|
||
|
||
// 处理一或两个浮点成员变量的结构体
|
||
if (isSFloNum(Ty->FSReg1Ty) || isSFloNum(Ty->FSReg2Ty)) {
|
||
Type *Regs[2] = {Ty->FSReg1Ty, Ty->FSReg2Ty};
|
||
for (int I = 0; I < 2; ++I) {
|
||
if (Regs[I]->Kind == TY_FLOAT) {
|
||
printLn(" # %d字节float结构体%d通过fa%d传递", Sz, I, FP);
|
||
printLn(" # 弹栈，将栈顶的值存入fa%d", FP);
|
||
printLn(" flw fa%d, 0(sp)", FP++);
|
||
printLn(" addi sp, sp, 8");
|
||
Depth--;
|
||
}
|
||
if (Regs[I]->Kind == TY_DOUBLE) {
|
||
printLn(" # %d字节double结构体%d通过fa%d传递", Sz, I, FP);
|
||
popF(FP++);
|
||
}
|
||
if (isInteger(Regs[I])) {
|
||
printLn(" # %d字节浮点结构体%d通过a%d传递", Sz, I, GP);
|
||
pop(GP++);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
// 其他整型结构体或多字节结构体
|
||
// 9~16字节整型结构体用两个寄存器，其他字节结构体用一个结构体
|
||
int Regs = (8 < Sz && Sz <= 16) ? 2 : 1;
|
||
for (int I = 1; I <= Regs; ++I) {
|
||
if (GP < GP_MAX) {
|
||
printLn(" # %d字节的整型结构体%d通过a%d传递", Sz, I, GP);
|
||
pop(GP++);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case TY_FLOAT:
|
||
case TY_DOUBLE:
|
||
if (FP < FP_MAX) {
|
||
printLn(" # fa%d传递浮点参数", FP);
|
||
popF(FP++);
|
||
} else if (GP < GP_MAX) {
|
||
printLn(" # a%d传递浮点参数", GP);
|
||
pop(GP++);
|
||
}
|
||
break;
|
||
case TY_LDOUBLE:
|
||
if (GP == GP_MAX - 1) {
|
||
printLn(" # a%d传递LD一半参数", GP);
|
||
pop(GP++);
|
||
}
|
||
if (GP < GP_MAX - 1) {
|
||
printLn(" # a%d传递long double第%d部分参数", GP, 1);
|
||
pop(GP++);
|
||
pop(GP++);
|
||
}
|
||
break;
|
||
default:
|
||
if (GP < GP_MAX) {
|
||
printLn(" # a%d传递整型参数", GP);
|
||
pop(GP++);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 调用函数
|
||
printLn(" # 调用函数");
|
||
printLn(" jalr t5");
|
||
|
||
if (Nd->Ty->Kind == TY_LDOUBLE) {
|
||
printLn(" # 保存Long double类型函数的返回值");
|
||
pushLD();
|
||
}
|
||
|
||
// 回收为栈传递的变量开辟的栈空间
|
||
if (StackArgs) {
|
||
// 栈的深度减去栈传递参数的字节数
|
||
Depth -= StackArgs;
|
||
printLn(" # 回收栈传递参数的%d个字节", StackArgs * 8);
|
||
printLn(" addi sp, sp, %d", StackArgs * 8);
|
||
// 清除记录的大结构体的数量
|
||
BSDepth = 0;
|
||
}
|
||
|
||
// 清除寄存器中高位无关的数据
|
||
switch (Nd->Ty->Kind) {
|
||
case TY_BOOL:
|
||
printLn(" # 清除bool类型的高位");
|
||
printLn(" slli a0, a0, 63");
|
||
printLn(" srli a0, a0, 63");
|
||
return;
|
||
case TY_CHAR:
|
||
printLn(" # 清除char类型的高位");
|
||
if (Nd->Ty->IsUnsigned) {
|
||
printLn(" slli a0, a0, 56");
|
||
printLn(" srli a0, a0, 56");
|
||
} else {
|
||
printLn(" slli a0, a0, 56");
|
||
printLn(" srai a0, a0, 56");
|
||
}
|
||
return;
|
||
case TY_SHORT:
|
||
printLn(" # 清除short类型的高位");
|
||
if (Nd->Ty->IsUnsigned) {
|
||
printLn(" slli a0, a0, 48");
|
||
printLn(" srli a0, a0, 48");
|
||
} else {
|
||
printLn(" slli a0, a0, 48");
|
||
printLn(" srai a0, a0, 48");
|
||
}
|
||
return;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
// 如果返回的结构体小于16字节，直接使用寄存器返回
|
||
if (Nd->RetBuffer && Nd->Ty->Size <= 16) {
|
||
copyRetBuffer(Nd->RetBuffer);
|
||
printLn(" li t0, %d", Nd->RetBuffer->Offset);
|
||
printLn(" add a0, fp, t0");
|
||
}
|
||
|
||
return;
|
||
}
|
||
case ND_LABEL_VAL:
|
||
printLn(" # 加载标签%s的值到a0中", Nd->UniqueLabel);
|
||
printLn(" la a0, %s", Nd->UniqueLabel);
|
||
return;
|
||
case ND_CAS: {
|
||
printLn("# =====原子比较交换===============");
|
||
// 当 t1地址中的值t0 与 t3旧值 相同时，将 t1地址中的值 替换为 t4新值
|
||
// 若不同时，将 地址中的值t0 替换掉 旧值
|
||
genExpr(Nd->CasAddr);
|
||
printLn(" mv t1, a0"); // t1地址
|
||
genExpr(Nd->CasOld);
|
||
printLn(" mv t2, a0"); // t2旧值地址
|
||
load(Nd->CasOld->Ty->Base);
|
||
printLn(" mv t3, a0"); // t3旧值
|
||
genExpr(Nd->CasNew);
|
||
printLn(" mv t4, a0"); // t4新值
|
||
|
||
// fence用于控制设备、内存的读写顺序
|
||
// iorw：之前的设备输入输出、内存读写指令，不能晚于fence指令
|
||
// ow：之后的设备输出、内存写的指令，不能早于fence指令
|
||
printLn(" fence iorw, ow");
|
||
printLn("1:");
|
||
// 加载地址中的值到t0
|
||
// lr（Load-Reserved）：加载并保留对该内存地址的控制权
|
||
// aq（acquisition）：若设置了aq位，
|
||
// 则此硬件线程中在AMO（原子内存操作）之后的任何内存操作，都不会在AMO之前发生
|
||
printLn(" lr.w.aq t0, (t1)");
|
||
// 地址的值和旧值比较，若不等则退出
|
||
printLn(" bne t0, t3, 2f");
|
||
// 写入新值到地址
|
||
// sc（Store-Conditional）：将寄存器中的值写入指定内存地址。
|
||
// 写入操作只有在该内存地址仍然被处理器保留时才会生效。
|
||
printLn(" sc.w.aq a0, t4, (t1)");
|
||
// 不为0时，写入失败，重新写入
|
||
printLn(" bnez a0, 1b");
|
||
|
||
printLn("2:");
|
||
// t0地址中的值 减去 t3旧值，将 差值 存入 t3
|
||
printLn(" subw t3, t0, t3");
|
||
// 判断差值t3，t3为0时 返回值a0为1，t3不为0时 返回值a0为0
|
||
printLn(" seqz a0, t3");
|
||
// 判断差值t3，t3为0时跳转到最后
|
||
printLn(" beqz t3, 3f");
|
||
// 若不同时，将 地址中的值t0 写入 t2旧值的地址，替换掉 旧值
|
||
printLn(" sw t0, (t2)");
|
||
printLn("3:");
|
||
return;
|
||
}
|
||
case ND_EXCH: {
|
||
genExpr(Nd->LHS);
|
||
push();
|
||
genExpr(Nd->RHS);
|
||
pop(1);
|
||
|
||
int Sz = Nd->LHS->Ty->Base->Size;
|
||
char *S = (Sz <= 4) ? "w" : "d";
|
||
printLn(" # 原子交换");
|
||
printLn(" amoswap.%s.aq a0, a0, (a1)", S);
|
||
return;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
|
||
// 处理浮点类型
|
||
switch (Nd->LHS->Ty->Kind) {
|
||
case TY_FLOAT:
|
||
case TY_DOUBLE: {
|
||
// 递归到最右节点
|
||
genExpr(Nd->RHS);
|
||
// 将结果压入栈
|
||
pushF();
|
||
// 递归到左节点
|
||
genExpr(Nd->LHS);
|
||
// 将结果弹栈到fa1
|
||
popF(1);
|
||
|
||
// 生成各个二叉树节点
|
||
// float对应s(single)后缀，double对应d(double)后缀
|
||
char *Suffix = (Nd->LHS->Ty->Kind == TY_FLOAT) ? "s" : "d";
|
||
|
||
switch (Nd->Kind) {
|
||
case ND_ADD:
|
||
printLn(" # fa0+fa1，结果写入fa0");
|
||
printLn(" fadd.%s fa0, fa0, fa1", Suffix);
|
||
return;
|
||
case ND_SUB:
|
||
printLn(" # fa0-fa1，结果写入fa0");
|
||
printLn(" fsub.%s fa0, fa0, fa1", Suffix);
|
||
return;
|
||
case ND_MUL:
|
||
printLn(" # fa0×fa1，结果写入fa0");
|
||
printLn(" fmul.%s fa0, fa0, fa1", Suffix);
|
||
return;
|
||
case ND_DIV:
|
||
printLn(" # fa0÷fa1，结果写入fa0");
|
||
printLn(" fdiv.%s fa0, fa0, fa1", Suffix);
|
||
return;
|
||
case ND_EQ:
|
||
printLn(" # 判断是否fa0=fa1");
|
||
printLn(" feq.%s a0, fa0, fa1", Suffix);
|
||
return;
|
||
case ND_NE:
|
||
printLn(" # 判断是否fa0≠fa1");
|
||
printLn(" feq.%s a0, fa0, fa1", Suffix);
|
||
printLn(" seqz a0, a0");
|
||
return;
|
||
case ND_LT:
|
||
printLn(" # 判断是否fa0<fa1");
|
||
printLn(" flt.%s a0, fa0, fa1", Suffix);
|
||
return;
|
||
case ND_LE:
|
||
printLn(" # 判断是否fa0≤fa1");
|
||
printLn(" fle.%s a0, fa0, fa1", Suffix);
|
||
return;
|
||
default:
|
||
errorTok(Nd->Tok, "invalid expression");
|
||
}
|
||
}
|
||
case TY_LDOUBLE: {
|
||
genExpr(Nd->LHS);
|
||
genExpr(Nd->RHS);
|
||
|
||
popLD(2);
|
||
popLD(0);
|
||
switch (Nd->Kind) {
|
||
case ND_ADD:
|
||
printLn(" # long double加法，从栈顶读取32个字节");
|
||
printLn(" call __addtf3@plt");
|
||
pushLD();
|
||
return;
|
||
case ND_SUB:
|
||
printLn(" # long double减法，从栈顶读取32个字节");
|
||
printLn(" call __subtf3@plt");
|
||
pushLD();
|
||
return;
|
||
case ND_MUL:
|
||
printLn(" # long double乘法，从栈顶读取32个字节");
|
||
printLn(" call __multf3@plt");
|
||
pushLD();
|
||
return;
|
||
case ND_DIV:
|
||
printLn(" # long double除法，从栈顶读取32个字节");
|
||
printLn(" call __divtf3@plt");
|
||
pushLD();
|
||
return;
|
||
case ND_EQ:
|
||
printLn(" # long double相等，从栈顶读取32个字节");
|
||
printLn(" call __eqtf2@plt");
|
||
printLn(" seqz a0, a0");
|
||
return;
|
||
case ND_NE:
|
||
printLn(" # long double不等，从栈顶读取32个字节");
|
||
printLn(" call __netf2@plt");
|
||
printLn(" snez a0, a0");
|
||
return;
|
||
case ND_LT:
|
||
printLn(" # long double小于，从栈顶读取32个字节");
|
||
printLn(" call __lttf2@plt");
|
||
printLn(" slti a0, a0, 0");
|
||
return;
|
||
case ND_LE:
|
||
printLn(" # long double小于等于，从栈顶读取32个字节");
|
||
printLn(" call __letf2@plt");
|
||
printLn(" slti a0, a0, 1");
|
||
return;
|
||
default:
|
||
errorTok(Nd->Tok, "invalid expression");
|
||
}
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
|
||
// 递归到最右节点
|
||
genExpr(Nd->RHS);
|
||
// 将结果压入栈
|
||
push();
|
||
// 递归到左节点
|
||
genExpr(Nd->LHS);
|
||
// 将结果弹栈到a1
|
||
pop(1);
|
||
|
||
// 生成各个二叉树节点
|
||
char *Suffix = Nd->LHS->Ty->Kind == TY_LONG || Nd->LHS->Ty->Base ? "" : "w";
|
||
switch (Nd->Kind) {
|
||
case ND_ADD: // + a0=a0+a1
|
||
printLn(" # a0+a1，结果写入a0");
|
||
printLn(" add%s a0, a0, a1", Suffix);
|
||
return;
|
||
case ND_SUB: // - a0=a0-a1
|
||
printLn(" # a0-a1，结果写入a0");
|
||
printLn(" sub%s a0, a0, a1", Suffix);
|
||
return;
|
||
case ND_MUL: // * a0=a0*a1
|
||
printLn(" # a0×a1，结果写入a0");
|
||
printLn(" mul%s a0, a0, a1", Suffix);
|
||
return;
|
||
case ND_DIV: // / a0=a0/a1
|
||
printLn(" # a0÷a1，结果写入a0");
|
||
if (Nd->Ty->IsUnsigned)
|
||
printLn(" divu%s a0, a0, a1", Suffix);
|
||
else
|
||
printLn(" div%s a0, a0, a1", Suffix);
|
||
return;
|
||
case ND_MOD: // % a0=a0%a1
|
||
printLn(" # a0%%a1，结果写入a0");
|
||
if (Nd->Ty->IsUnsigned)
|
||
printLn(" remu%s a0, a0, a1", Suffix);
|
||
else
|
||
printLn(" rem%s a0, a0, a1", Suffix);
|
||
return;
|
||
case ND_BITAND: // & a0=a0&a1
|
||
printLn(" # a0&a1，结果写入a0");
|
||
printLn(" and a0, a0, a1");
|
||
return;
|
||
case ND_BITOR: // | a0=a0|a1
|
||
printLn(" # a0|a1，结果写入a0");
|
||
printLn(" or a0, a0, a1");
|
||
return;
|
||
case ND_BITXOR: // ^ a0=a0^a1
|
||
printLn(" # a0^a1，结果写入a0");
|
||
printLn(" xor a0, a0, a1");
|
||
return;
|
||
case ND_EQ:
|
||
case ND_NE:
|
||
if (Nd->LHS->Ty->IsUnsigned && Nd->LHS->Ty->Kind == TY_INT) {
|
||
printLn(" # 左部是U32类型，需要截断");
|
||
printLn("slli a0, a0, 32");
|
||
printLn("srli a0, a0, 32");
|
||
};
|
||
if (Nd->RHS->Ty->IsUnsigned && Nd->RHS->Ty->Kind == TY_INT) {
|
||
printLn(" # 右部是U32类型，需要截断");
|
||
printLn("slli a1, a1, 32");
|
||
printLn("srli a1, a1, 32");
|
||
};
|
||
// a0=a0^a1，异或指令
|
||
printLn(" # 判断是否a0%sa1", Nd->Kind == ND_EQ ? "=" : "≠");
|
||
printLn(" xor a0, a0, a1");
|
||
|
||
if (Nd->Kind == ND_EQ)
|
||
// a0==a1
|
||
// a0=a0^a1, sltiu a0, a0, 1
|
||
// 等于0则置1
|
||
printLn(" seqz a0, a0");
|
||
else
|
||
// a0!=a1
|
||
// a0=a0^a1, sltu a0, x0, a0
|
||
// 不等于0则置1
|
||
printLn(" snez a0, a0");
|
||
return;
|
||
case ND_LT:
|
||
printLn(" # 判断a0<a1");
|
||
if (Nd->LHS->Ty->IsUnsigned)
|
||
printLn(" sltu a0, a0, a1");
|
||
else
|
||
printLn(" slt a0, a0, a1");
|
||
return;
|
||
case ND_LE:
|
||
// a0<=a1等价于
|
||
// a0=a1<a0, a0=a0^1
|
||
printLn(" # 判断是否a0≤a1");
|
||
if (Nd->LHS->Ty->IsUnsigned)
|
||
printLn(" sltu a0, a1, a0");
|
||
else
|
||
printLn(" slt a0, a1, a0");
|
||
printLn(" xori a0, a0, 1");
|
||
return;
|
||
case ND_SHL:
|
||
printLn(" # a0逻辑左移a1位");
|
||
printLn(" sll%s a0, a0, a1", Suffix);
|
||
return;
|
||
case ND_SHR:
|
||
printLn(" # a0算术右移a1位");
|
||
if (Nd->Ty->IsUnsigned)
|
||
printLn(" srl%s a0, a0, a1", Suffix);
|
||
else
|
||
printLn(" sra%s a0, a0, a1", Suffix);
|
||
return;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
errorTok(Nd->Tok, "invalid expression");
|
||
}
|
||
|
||
// 生成语句
|
||
static void genStmt(Node *Nd) {
|
||
// .loc 文件编号 行号
|
||
printLn(" .loc %d %d", Nd->Tok->File->FileNo, Nd->Tok->LineNo);
|
||
|
||
switch (Nd->Kind) {
|
||
// 生成if语句
|
||
case ND_IF: {
|
||
// 代码段计数
|
||
int C = count();
|
||
printLn("\n# =====分支语句%d==============", C);
|
||
// 生成条件内语句
|
||
printLn("\n# Cond表达式%d", C);
|
||
genExpr(Nd->Cond);
|
||
notZero(Nd->Cond->Ty);
|
||
// 判断结果是否为0，为0则跳转到else标签
|
||
printLn(" # 若a0为0，则跳转到分支%d的.L.else.%d段", C, C);
|
||
printLn(" beqz a0, .L.else.%d", C);
|
||
// 生成符合条件后的语句
|
||
printLn("\n# Then语句%d", C);
|
||
genStmt(Nd->Then);
|
||
// 执行完后跳转到if语句后面的语句
|
||
printLn(" # 跳转到分支%d的.L.end.%d段", C, C);
|
||
printLn(" j .L.end.%d", C);
|
||
// else代码块，else可能为空，故输出标签
|
||
printLn("\n# Else语句%d", C);
|
||
printLn("# 分支%d的.L.else.%d段标签", C, C);
|
||
printLn(".L.else.%d:", C);
|
||
// 生成不符合条件后的语句
|
||
if (Nd->Els)
|
||
genStmt(Nd->Els);
|
||
// 结束if语句，继续执行后面的语句
|
||
printLn("\n# 分支%d的.L.end.%d段标签", C, C);
|
||
printLn(".L.end.%d:", C);
|
||
return;
|
||
}
|
||
// 生成for或while循环语句
|
||
case ND_FOR: {
|
||
// 代码段计数
|
||
int C = count();
|
||
printLn("\n# =====循环语句%d===============", C);
|
||
// 生成初始化语句
|
||
if (Nd->Init) {
|
||
printLn("\n# Init语句%d", C);
|
||
genStmt(Nd->Init);
|
||
}
|
||
// 输出循环头部标签
|
||
printLn("\n# 循环%d的.L.begin.%d段标签", C, C);
|
||
printLn(".L.begin.%d:", C);
|
||
// 处理循环条件语句
|
||
printLn("# Cond表达式%d", C);
|
||
if (Nd->Cond) {
|
||
// 生成条件循环语句
|
||
genExpr(Nd->Cond);
|
||
notZero(Nd->Cond->Ty);
|
||
// 判断结果是否为0，为0则跳转到结束部分
|
||
printLn(" # 若a0为0，则跳转到循环%d的%s段", C, Nd->BrkLabel);
|
||
printLn(" beqz a0, %s", Nd->BrkLabel);
|
||
}
|
||
// 生成循环体语句
|
||
printLn("\n# Then语句%d", C);
|
||
genStmt(Nd->Then);
|
||
// continue标签语句
|
||
printLn("%s:", Nd->ContLabel);
|
||
// 处理循环递增语句
|
||
if (Nd->Inc) {
|
||
printLn("\n# Inc语句%d", C);
|
||
// 生成循环递增语句
|
||
genExpr(Nd->Inc);
|
||
}
|
||
// 跳转到循环头部
|
||
printLn(" # 跳转到循环%d的.L.begin.%d段", C, C);
|
||
printLn(" j .L.begin.%d", C);
|
||
// 输出循环尾部标签
|
||
printLn("\n# 循环%d的%s段标签", C, Nd->BrkLabel);
|
||
printLn("%s:", Nd->BrkLabel);
|
||
return;
|
||
}
|
||
// 生成do while语句
|
||
case ND_DO: {
|
||
int C = count();
|
||
printLn("\n# =====do while语句%d============", C);
|
||
printLn("\n# begin语句%d", C);
|
||
printLn(".L.begin.%d:", C);
|
||
|
||
printLn("\n# Then语句%d", C);
|
||
genStmt(Nd->Then);
|
||
|
||
printLn("\n# Cond语句%d", C);
|
||
printLn("%s:", Nd->ContLabel);
|
||
genExpr(Nd->Cond);
|
||
|
||
notZero(Nd->Cond->Ty);
|
||
printLn(" # 跳转到循环%d的.L.begin.%d段", C, C);
|
||
printLn(" bnez a0, .L.begin.%d", C);
|
||
|
||
printLn("\n# 循环%d的%s段标签", C, Nd->BrkLabel);
|
||
printLn("%s:", Nd->BrkLabel);
|
||
return;
|
||
}
|
||
case ND_SWITCH:
|
||
printLn("\n# =====switch语句===============");
|
||
genExpr(Nd->Cond);
|
||
|
||
printLn(" # 遍历跳转到值等于a0的case标签");
|
||
for (Node *N = Nd->CaseNext; N; N = N->CaseNext) {
|
||
// 常规case，case范围前后一致
|
||
if (N->Begin == N->End) {
|
||
printLn(" li t0, %ld", N->Begin);
|
||
printLn(" beq a0, t0, %s", N->Label);
|
||
continue;
|
||
}
|
||
|
||
printLn(" # 处理case范围值：%ld...%ld", N->Begin, N->End);
|
||
// a0为当前switch中的值
|
||
printLn(" mv t1, a0");
|
||
printLn(" li t0, %ld", N->Begin);
|
||
// t1存储了a0-Begin的值
|
||
printLn(" sub t1, t1, t0");
|
||
// t2存储了End-Begin的值
|
||
printLn(" li t2, %ld", N->End - N->Begin);
|
||
// 如果0<=t1<=t2，那么就说明在范围内
|
||
printLn(" bleu t1, t2, %s", N->Label);
|
||
}
|
||
|
||
if (Nd->DefaultCase) {
|
||
printLn(" # 跳转到default标签");
|
||
printLn(" j %s", Nd->DefaultCase->Label);
|
||
}
|
||
|
||
printLn(" # 结束switch，跳转break标签");
|
||
printLn(" j %s", Nd->BrkLabel);
|
||
// 生成case标签的语句
|
||
genStmt(Nd->Then);
|
||
printLn("# switch的break标签，结束switch");
|
||
printLn("%s:", Nd->BrkLabel);
|
||
return;
|
||
case ND_CASE:
|
||
printLn("# case标签，值为%ld", Nd->Val);
|
||
printLn("%s:", Nd->Label);
|
||
genStmt(Nd->LHS);
|
||
return;
|
||
// 生成代码块，遍历代码块的语句链表
|
||
case ND_BLOCK:
|
||
for (Node *N = Nd->Body; N; N = N->Next)
|
||
genStmt(N);
|
||
return;
|
||
// goto语句
|
||
case ND_GOTO:
|
||
printLn(" j %s", Nd->UniqueLabel);
|
||
return;
|
||
case ND_GOTO_EXPR:
|
||
printLn(" # GOTO跳转到存储标签的地址");
|
||
genExpr(Nd->LHS);
|
||
printLn(" jr a0");
|
||
return;
|
||
// 标签语句
|
||
case ND_LABEL:
|
||
printLn("%s:", Nd->UniqueLabel);
|
||
genStmt(Nd->LHS);
|
||
return;
|
||
// 生成return语句
|
||
case ND_RETURN:
|
||
printLn("# 返回语句");
|
||
// 不为空返回语句时
|
||
if (Nd->LHS) {
|
||
genExpr(Nd->LHS);
|
||
|
||
Type *Ty = Nd->LHS->Ty;
|
||
// 处理结构体作为返回值的情况
|
||
if (Ty->Kind == TY_STRUCT || Ty->Kind == TY_UNION) {
|
||
if (Ty->Size <= 16)
|
||
// 小于16字节拷贝寄存器
|
||
copyStructReg();
|
||
else
|
||
// 大于16字节拷贝内存
|
||
copyStructMem();
|
||
}
|
||
if (Ty->Kind == TY_LDOUBLE) {
|
||
printLn(" # LD类型作为返回值时，需要将LD栈顶元素拷贝到a0，a1中");
|
||
popLD(0);
|
||
}
|
||
}
|
||
// 无条件跳转语句，跳转到.L.return段
|
||
// j offset是 jal x0, offset的别名指令
|
||
printLn(" # 跳转到.L.return.%s段", CurrentFn->Name);
|
||
printLn(" j .L.return.%s", CurrentFn->Name);
|
||
return;
|
||
// 生成表达式语句
|
||
case ND_EXPR_STMT:
|
||
genExpr(Nd->LHS);
|
||
return;
|
||
case ND_ASM:
|
||
printLn(" # 插入的ASM代码片段");
|
||
printLn(" %s", Nd->AsmStr);
|
||
return;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
errorTok(Nd->Tok, "invalid statement");
|
||
}
|
||
|
||
// 根据变量的链表计算出偏移量
|
||
static void assignLVarOffsets(Obj *Prog) {
|
||
// 为每个函数计算其变量所用的栈空间
|
||
for (Obj *Fn = Prog; Fn; Fn = Fn->Next) {
|
||
// 如果不是函数,则终止
|
||
if (!Fn->IsFunction)
|
||
continue;
|
||
|
||
// 反向偏移量
|
||
int ReOffset = 16;
|
||
|
||
// 被调用函数将自己的ra、fp也压入栈了，
|
||
// 所以fp+16才是上一级函数的sp顶
|
||
// / 栈保存的N个变量 / N*8
|
||
// /---------------本级函数----------------/ sp
|
||
// / ra / sp-8
|
||
// / fp（上一级） / fp = sp-16
|
||
|
||
// 寄存器传递
|
||
int GP = 0, FP = 0;
|
||
// 寄存器传递的参数
|
||
for (Obj *Var = Fn->Params; Var; Var = Var->Next) {
|
||
// 读取形参类型
|
||
Type *Ty = Var->Ty;
|
||
|
||
switch (Ty->Kind) {
|
||
case TY_STRUCT:
|
||
case TY_UNION:
|
||
setFloStMemsTy(&Ty, GP, FP);
|
||
|
||
// 计算浮点结构体所使用的寄存器
|
||
// 这里一定寄存器可用，所以不判定是否超过寄存器最大值
|
||
if (isSFloNum(Ty->FSReg1Ty) || isSFloNum(Ty->FSReg2Ty)) {
|
||
Type *Regs[2] = {Ty->FSReg1Ty, Ty->FSReg2Ty};
|
||
for (int I = 0; I < 2; ++I) {
|
||
if (isSFloNum(Regs[I]))
|
||
FP++;
|
||
if (isInteger(Regs[I]))
|
||
GP++;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// 9～16字节的结构体要用两个寄存器
|
||
if (8 < Ty->Size && Ty->Size <= 16) {
|
||
// 如果只剩一个寄存器，那么剩余一半通过栈传递
|
||
if (GP == GP_MAX - 1)
|
||
Var->IsHalfByStack = true;
|
||
if (GP < GP_MAX)
|
||
GP++;
|
||
}
|
||
// 所有字节的结构体都在至少使用了一个寄存器（如果可用）
|
||
if (GP < GP_MAX) {
|
||
GP++;
|
||
continue;
|
||
}
|
||
|
||
// 没使用寄存器的需要栈传递
|
||
break;
|
||
case TY_FLOAT:
|
||
case TY_DOUBLE:
|
||
if (FP < FP_MAX) {
|
||
printLn(" # FP%d传递浮点变量%s", FP, Var->Name);
|
||
FP++;
|
||
continue;
|
||
} else if (GP < GP_MAX) {
|
||
printLn(" # GP%d传递浮点变量%s", GP, Var->Name);
|
||
GP++;
|
||
continue;
|
||
}
|
||
break;
|
||
case TY_LDOUBLE:
|
||
if (GP == GP_MAX - 1) {
|
||
printLn(" # GP%d传递一半浮点变量%s，另一半栈传递", GP, Var->Name);
|
||
Var->IsHalfByStack = true;
|
||
GP++;
|
||
break;
|
||
}
|
||
if (GP < GP_MAX - 1) {
|
||
printLn(" # GP%d传递浮点变量%s", GP, Var->Name);
|
||
GP++;
|
||
GP++;
|
||
continue;
|
||
}
|
||
break;
|
||
default:
|
||
if (GP < GP_MAX) {
|
||
printLn(" # GP%d传递整型变量%s", GP, Var->Name);
|
||
GP++;
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
|
||
// 栈传递
|
||
|
||
// 对齐变量
|
||
ReOffset = alignTo(ReOffset, 8);
|
||
// 为栈传递变量赋一个偏移量，或者说是反向栈地址
|
||
Var->Offset = ReOffset;
|
||
// 栈传递变量计算反向偏移量，传递一半的结构体减去寄存器的部分
|
||
ReOffset += Var->IsHalfByStack ? Var->Ty->Size - 8 : Var->Ty->Size;
|
||
printLn(" # 栈传递变量%s偏移量%d", Var->Name, Var->Offset);
|
||
}
|
||
|
||
// 可变参数函数VaArea的偏移量
|
||
if (Fn->VaArea) {
|
||
ReOffset = alignTo(ReOffset, 8);
|
||
Fn->VaArea->Offset = ReOffset;
|
||
}
|
||
|
||
int Offset = 0;
|
||
// 读取所有变量
|
||
for (Obj *Var = Fn->Locals; Var; Var = Var->Next) {
|
||
// 栈传递的变量的直接跳过
|
||
if (Var->Offset && !Var->IsHalfByStack)
|
||
continue;
|
||
|
||
// 数组超过16字节时，对齐值至少为16字节
|
||
int Align = (Var->Ty->Kind == TY_ARRAY && Var->Ty->Size >= 16)
|
||
? MAX(16, Var->Align)
|
||
: Var->Align;
|
||
|
||
// 每个变量分配空间
|
||
Offset += Var->Ty->Size;
|
||
// 对齐变量
|
||
Offset = alignTo(Offset, Align);
|
||
// 为每个变量赋一个偏移量，或者说是栈中地址
|
||
Var->Offset = -Offset;
|
||
printLn(" # 寄存器传递变量%s偏移量%d", Var->Name, Var->Offset);
|
||
}
|
||
// 将栈对齐到16字节
|
||
Fn->StackSize = alignTo(Offset, 16);
|
||
}
|
||
}
|
||
|
||
// 返回2^N的N值
|
||
static int simpleLog2(int Num) {
|
||
int N = Num;
|
||
int E = 0;
|
||
while (N > 1) {
|
||
if (N % 2 == 1)
|
||
error("Wrong value %d", Num);
|
||
N /= 2;
|
||
++E;
|
||
}
|
||
return E;
|
||
}
|
||
|
||
static void emitData(Obj *Prog) {
|
||
for (Obj *Var = Prog; Var; Var = Var->Next) {
|
||
// 跳过是函数或者无定义的变量
|
||
if (Var->IsFunction || !Var->IsDefinition)
|
||
continue;
|
||
|
||
if (Var->IsStatic) {
|
||
printLn("\n # static全局变量%s", Var->Name);
|
||
printLn(" .local %s", Var->Name);
|
||
} else {
|
||
printLn("\n # 全局变量%s", Var->Name);
|
||
printLn(" .globl %s", Var->Name);
|
||
}
|
||
|
||
printLn(" # 对齐全局变量");
|
||
if (!Var->Align)
|
||
error("Align can not be 0!");
|
||
// 数组超过16字节时，对齐值至少为16字节
|
||
int Align = (Var->Ty->Kind == TY_ARRAY && Var->Ty->Size >= 16)
|
||
? MAX(16, Var->Align)
|
||
: Var->Align;
|
||
|
||
// 为试探性的全局变量生成指示
|
||
if (OptFCommon && Var->IsTentative) {
|
||
printLn(" .comm %s, %d, %d", Var->Name, Var->Ty->Size, Align);
|
||
continue;
|
||
}
|
||
|
||
// 判断是否有初始值
|
||
// .data 或 .tdata 段
|
||
if (Var->InitData) {
|
||
if (Var->IsTLS) {
|
||
printLn("\n # TLS数据段标签");
|
||
// a：可加载执行
|
||
// w：可写
|
||
// T：线程局部的
|
||
// progbits：包含程序数据
|
||
printLn(" .section .tdata,\"awT\",@progbits");
|
||
} else {
|
||
printLn("\n # 数据段标签");
|
||
printLn(" .data");
|
||
}
|
||
|
||
printLn(" .type %s, @object", Var->Name);
|
||
printLn(" .size %s, %d", Var->Name, Var->Ty->Size);
|
||
printLn(" .align %d", simpleLog2(Align));
|
||
printLn("%s:", Var->Name);
|
||
Relocation *Rel = Var->Rel;
|
||
int Pos = 0;
|
||
while (Pos < Var->Ty->Size) {
|
||
if (Rel && Rel->Offset == Pos) {
|
||
// 使用其他变量进行初始化
|
||
printLn(" # %s全局变量", Var->Name);
|
||
printLn(" .quad %s%+ld", *Rel->Label, Rel->Addend);
|
||
Rel = Rel->Next;
|
||
Pos += 8;
|
||
} else {
|
||
// 打印出字符串的内容，包括转义字符
|
||
char C = Var->InitData[Pos++];
|
||
if (isprint(C))
|
||
printLn(" .byte %d\t# 字符：%c", C, C);
|
||
else
|
||
printLn(" .byte %d", C);
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// bss段未给数据分配空间，只记录数据所需空间的大小
|
||
// .bss 或 .tbss 段
|
||
if (Var->IsTLS) {
|
||
// nobits：不含数据
|
||
printLn("\n # TLS未初始化的全局变量");
|
||
printLn(" .section .tbss,\"awT\",@nobits");
|
||
} else {
|
||
printLn("\n # 未初始化的全局变量");
|
||
printLn(" .bss");
|
||
}
|
||
|
||
printLn(" .align %d", simpleLog2(Align));
|
||
printLn("%s:", Var->Name);
|
||
printLn(" # 全局变量零填充%d字节", Var->Ty->Size);
|
||
printLn(" .zero %d", Var->Ty->Size);
|
||
}
|
||
}
|
||
|
||
// 将浮点寄存器的值存入栈中
|
||
static void storeFloat(int Reg, int Offset, int Sz) {
|
||
printLn(" # 将fa%d寄存器的值存入%d(fp)的栈地址", Reg, Offset);
|
||
printLn(" li t0, %d", Offset);
|
||
printLn(" add t0, fp, t0");
|
||
|
||
switch (Sz) {
|
||
case 4:
|
||
printLn(" fsw fa%d, 0(t0)", Reg);
|
||
return;
|
||
case 8:
|
||
printLn(" fsd fa%d, 0(t0)", Reg);
|
||
return;
|
||
default:
|
||
unreachable();
|
||
}
|
||
}
|
||
|
||
// 将整形寄存器的值存入栈中
|
||
static void storeGeneral(int Reg, int Offset, int Size) {
|
||
printLn(" # 将a%d寄存器的值存入%d(fp)的栈地址", Reg, Offset);
|
||
printLn(" li t0, %d", Offset);
|
||
printLn(" add t0, fp, t0");
|
||
switch (Size) {
|
||
case 1:
|
||
printLn(" sb a%d, 0(t0)", Reg);
|
||
return;
|
||
case 2:
|
||
printLn(" sh a%d, 0(t0)", Reg);
|
||
return;
|
||
case 4:
|
||
printLn(" sw a%d, 0(t0)", Reg);
|
||
return;
|
||
case 8:
|
||
printLn(" sd a%d, 0(t0)", Reg);
|
||
return;
|
||
}
|
||
unreachable();
|
||
}
|
||
|
||
// 存储结构体到栈内开辟的空间
|
||
static void storeStruct(int Reg, int Offset, int Size) {
|
||
// t0是结构体的地址，复制t0指向的结构体到栈相应的位置中
|
||
for (int I = 0; I < Size; I++) {
|
||
printLn(" lb t0, %d(a%d)", I, Reg);
|
||
|
||
printLn(" li t1, %d", Offset + I);
|
||
printLn(" add t1, fp, t1");
|
||
printLn(" sb t0, 0(t1)");
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 代码生成入口函数，包含代码块的基础信息
|
||
void emitText(Obj *Prog) {
|
||
// 为每个函数单独生成代码
|
||
for (Obj *Fn = Prog; Fn; Fn = Fn->Next) {
|
||
if (!Fn->IsFunction || !Fn->IsDefinition)
|
||
continue;
|
||
|
||
// 如果未存活，就不生成static inline函数
|
||
if (!Fn->IsLive)
|
||
continue;
|
||
|
||
if (Fn->IsStatic) {
|
||
printLn("\n # 定义局部%s函数", Fn->Name);
|
||
printLn(" .local %s", Fn->Name);
|
||
} else {
|
||
printLn("\n # 定义全局%s函数", Fn->Name);
|
||
printLn(" .globl %s", Fn->Name);
|
||
}
|
||
|
||
printLn(" # 代码段标签");
|
||
printLn(" .text");
|
||
printLn("# =====%s段开始===============", Fn->Name);
|
||
printLn("# %s段标签", Fn->Name);
|
||
printLn(" .type %s, @function", Fn->Name);
|
||
printLn("%s:", Fn->Name);
|
||
CurrentFn = Fn;
|
||
|
||
// 栈布局
|
||
// ------------------------------//
|
||
// 上一级函数的栈传递参数
|
||
// ==============================// sp（本级函数）
|
||
// VaArea(寄存器可用时)
|
||
// ------------------------------// sp = sp（本级函数）-VaArea
|
||
// ra
|
||
//-------------------------------// ra = sp-8
|
||
// fp
|
||
//-------------------------------// fp = sp-16
|
||
// 变量
|
||
//-------------------------------// sp = sp-16-StackSize
|
||
// 表达式计算
|
||
//-------------------------------//
|
||
|
||
// Prologue, 前言
|
||
|
||
// 为剩余的整型寄存器开辟空间，用于存储可变参数
|
||
int VaSize = 0;
|
||
if (Fn->VaArea) {
|
||
// 遍历正常参数所使用的浮点、整型寄存器
|
||
int GPs = 0, FPs = 0;
|
||
|
||
// 可变参数函数，非可变的参数使用寄存器
|
||
for (Obj *Var = Fn->Params; Var; Var = Var->Next) {
|
||
// 计算所有类型所使用的寄存器数量
|
||
Type *Ty = Var->Ty;
|
||
switch (Ty->Kind) {
|
||
case TY_STRUCT:
|
||
case TY_UNION:
|
||
// 对寄存器传递的参数
|
||
if (isSFloNum(Ty->FSReg1Ty) || isSFloNum(Ty->FSReg2Ty)) {
|
||
// 浮点结构体的第一部分
|
||
isSFloNum(Ty->FSReg1Ty) ? FPs++ : GPs++;
|
||
// 浮点结构体的第二部分
|
||
if (Ty->FSReg2Ty->Kind != TY_VOID)
|
||
isSFloNum(Ty->FSReg2Ty) ? FPs++ : GPs++;
|
||
break;
|
||
}
|
||
|
||
// 小于8字节的结构体、大于16字节的结构体
|
||
// 一半寄存器，一半栈传递的结构体
|
||
if (Ty->Size < 8 || Ty->Size > 16 || Var->IsHalfByStack)
|
||
GPs++;
|
||
// 处理大于8字节，小于16字节的结构体
|
||
else
|
||
GPs += 2;
|
||
break;
|
||
case TY_FLOAT:
|
||
case TY_DOUBLE:
|
||
// 可变参数函数中的浮点参数
|
||
FPs < FP_MAX ? FPs++ : GPs++;
|
||
break;
|
||
default:
|
||
// 可变参数函数中的整型参数
|
||
GPs++;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 需确保使用到了整形寄存器，否则不开辟此空间
|
||
if (GPs < GP_MAX) {
|
||
VaSize = (8 - GPs) * 8;
|
||
printLn(" # VaArea的区域，大小为%d", VaSize);
|
||
printLn(" addi sp, sp, -%d", VaSize);
|
||
}
|
||
}
|
||
|
||
// 将ra寄存器压栈,保存ra的值
|
||
printLn(" # 将ra寄存器压栈,保存ra的值");
|
||
printLn(" addi sp, sp, -16");
|
||
printLn(" sd ra, 8(sp)");
|
||
// 将fp压入栈中，保存fp的值
|
||
printLn(" # 将fp压栈，fp属于“被调用者保存”的寄存器，需要恢复原值");
|
||
printLn(" sd fp, 0(sp)");
|
||
// 将sp写入fp
|
||
printLn(" # 将sp的值写入fp");
|
||
printLn(" mv fp, sp");
|
||
|
||
printLn(" # 保存所有的fs0~fs11寄存器");
|
||
for (int I = 0; I <= 11; ++I)
|
||
printLn(" fsgnj.d ft%d, fs%d, fs%d", I, I, I);
|
||
|
||
// 偏移量为实际变量所用的栈大小
|
||
printLn(" # sp腾出StackSize大小的栈空间");
|
||
printLn(" li t0, -%d", Fn->StackSize);
|
||
printLn(" add sp, sp, t0");
|
||
// Alloca函数
|
||
printLn(" # 将当前的sp值，存入到Alloca区域的底部");
|
||
printLn(" li t0, %d", Fn->AllocaBottom->Offset);
|
||
printLn(" add t0, t0, fp");
|
||
printLn(" sd sp, 0(t0)");
|
||
|
||
// 正常传递的形参
|
||
// 记录整型寄存器，浮点寄存器使用的数量
|
||
int GP = 0, FP = 0;
|
||
for (Obj *Var = Fn->Params; Var; Var = Var->Next) {
|
||
// 不处理栈传递的形参，栈传递一半的结构体除外
|
||
if (Var->Offset > 0 && !Var->IsHalfByStack)
|
||
continue;
|
||
|
||
Type *Ty = Var->Ty;
|
||
|
||
// 正常传递的形参
|
||
switch (Ty->Kind) {
|
||
case TY_STRUCT:
|
||
case TY_UNION:
|
||
printLn(" # 对寄存器传递的结构体进行压栈");
|
||
|
||
// 处理浮点结构体
|
||
if (isSFloNum(Ty->FSReg1Ty) || isSFloNum(Ty->FSReg2Ty)) {
|
||
printLn(" # 浮点结构体的第一部分进行压栈");
|
||
// 浮点结构体的第一部分，偏移量为0
|
||
int Sz1 = Var->Ty->FSReg1Ty->Size;
|
||
if (isSFloNum(Ty->FSReg1Ty))
|
||
storeFloat(FP++, Var->Offset, Sz1);
|
||
else
|
||
storeGeneral(GP++, Var->Offset, Sz1);
|
||
|
||
// 浮点结构体的第二部分
|
||
if (Ty->FSReg2Ty->Kind != TY_VOID) {
|
||
printLn(" # 浮点结构体的第二部分进行压栈");
|
||
int Sz2 = Ty->FSReg2Ty->Size;
|
||
// 结构体内偏移量为两个成员间的最大尺寸
|
||
int Off = MAX(Sz1, Sz2);
|
||
|
||
if (isSFloNum(Ty->FSReg2Ty))
|
||
storeFloat(FP++, Var->Offset + Off, Sz2);
|
||
else
|
||
storeGeneral(GP++, Var->Offset + Off, Sz2);
|
||
}
|
||
break;
|
||
}
|
||
|
||
// 大于16字节的结构体参数，通过访问它的地址，
|
||
// 将原来位置的结构体复制到栈中
|
||
if (Ty->Size > 16) {
|
||
printLn(" # 大于16字节的结构体进行压栈");
|
||
storeStruct(GP++, Var->Offset, Ty->Size);
|
||
break;
|
||
}
|
||
|
||
// 一半寄存器、一半栈传递的结构体
|
||
if (Var->IsHalfByStack) {
|
||
printLn(" # 一半寄存器、一半栈传递结构体进行压栈");
|
||
storeGeneral(GP++, Var->Offset, 8);
|
||
// 拷贝栈传递的一半结构体到当前栈中
|
||
for (int I = 0; I != Var->Ty->Size - 8; ++I) {
|
||
printLn(" lb t0, %d(fp)", 16 + I);
|
||
|
||
printLn(" li t1, %d", Var->Offset + 8 + I);
|
||
printLn(" add t1, fp, t1");
|
||
printLn(" sb t0, 0(t1)");
|
||
}
|
||
break;
|
||
}
|
||
|
||
// 处理小于16字节的结构体
|
||
if (Ty->Size <= 16)
|
||
storeGeneral(GP++, Var->Offset, MIN(8, Ty->Size));
|
||
if (Ty->Size > 8)
|
||
storeGeneral(GP++, Var->Offset + 8, Ty->Size - 8);
|
||
break;
|
||
case TY_FLOAT:
|
||
case TY_DOUBLE:
|
||
// 正常传递的浮点形参
|
||
if (FP < FP_MAX) {
|
||
printLn(" # 将浮点形参%s的寄存器fa%d的值压栈", Var->Name, FP);
|
||
storeFloat(FP++, Var->Offset, Var->Ty->Size);
|
||
} else {
|
||
printLn(" # 将浮点形参%s的寄存器a%d的值压栈", Var->Name, GP);
|
||
storeGeneral(GP++, Var->Offset, Var->Ty->Size);
|
||
}
|
||
break;
|
||
case TY_LDOUBLE:
|
||
if (Var->IsHalfByStack) {
|
||
printLn(" # 将LD形参%s的第一部分a%d的值压栈", Var->Name, GP);
|
||
printLn(" ld t0, 16(fp)");
|
||
printLn(" sd t0, %d(fp)", Var->Offset + 8);
|
||
break;
|
||
}
|
||
if (GP < GP_MAX - 1) {
|
||
printLn(" # 将LD形参%s的第一部分a%d的值压栈", Var->Name, GP);
|
||
storeGeneral(GP++, Var->Offset, 8);
|
||
printLn(" # 将LD形参%s的第二部分a%d的值压栈", Var->Name, GP);
|
||
storeGeneral(GP++, Var->Offset + 8, 8);
|
||
}
|
||
break;
|
||
default:
|
||
// 正常传递的整型形参
|
||
printLn(" # 将整型形参%s的寄存器a%d的值压栈", Var->Name, GP);
|
||
storeGeneral(GP++, Var->Offset, Var->Ty->Size);
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 可变参数
|
||
if (Fn->VaArea) {
|
||
// 可变参数位置位于本函数的最上方，即sp的位置，也就是fp+16
|
||
|
||
// 可变参数存入__va_area__，注意最多为7个
|
||
int Offset = Fn->VaArea->Offset;
|
||
printLn(" # 可变参数VaArea的偏移量为%d", Fn->VaArea->Offset);
|
||
while (GP < GP_MAX) {
|
||
printLn(" # 可变参数，相对%s的偏移量为%d", Fn->VaArea->Name,
|
||
Offset - Fn->VaArea->Offset);
|
||
storeGeneral(GP++, Offset, 8);
|
||
Offset += 8;
|
||
}
|
||
}
|
||
|
||
// 生成语句链表的代码
|
||
printLn("# =====%s段主体===============", Fn->Name);
|
||
genStmt(Fn->Body);
|
||
assert(Depth == 0);
|
||
|
||
// main默认返回0
|
||
if (strcmp(Fn->Name, "main") == 0)
|
||
printLn(" li a0, 0");
|
||
|
||
// Epilogue，后语
|
||
// 输出return段标签
|
||
printLn("# =====%s段结束===============", Fn->Name);
|
||
printLn("# return段标签");
|
||
printLn(".L.return.%s:", Fn->Name);
|
||
|
||
printLn(" # 恢复所有的fs0~fs11寄存器");
|
||
for (int I = 0; I <= 11; ++I)
|
||
printLn(" fsgnj.d fs%d, ft%d, ft%d", I, I, I);
|
||
|
||
// 将fp的值改写回sp
|
||
printLn(" # 将fp的值写回sp");
|
||
printLn(" mv sp, fp");
|
||
// 将最早fp保存的值弹栈，恢复fp。
|
||
printLn(" # 将最早fp保存的值弹栈，恢复fp和sp");
|
||
printLn(" ld fp, 0(sp)");
|
||
// 将ra寄存器弹栈,恢复ra的值
|
||
printLn(" # 将ra寄存器弹栈,恢复ra的值");
|
||
printLn(" ld ra, 8(sp)");
|
||
printLn(" addi sp, sp, 16");
|
||
|
||
// 归还可变参数寄存器压栈的那一部分
|
||
if (Fn->VaArea && VaSize > 0) {
|
||
printLn(" # 归还VaArea的区域，大小为%d", VaSize);
|
||
printLn(" addi sp, sp, %d", VaSize);
|
||
}
|
||
|
||
// 返回
|
||
printLn(" # 返回a0值给系统调用");
|
||
printLn(" ret");
|
||
}
|
||
}
|
||
|
||
void codegen(Obj *Prog, FILE *Out) {
|
||
// 设置目标文件的文件流指针
|
||
OutputFile = Out;
|
||
|
||
// 获取所有的输入文件，并输出.file指示
|
||
File **Files = getInputFiles();
|
||
for (int I = 0; Files[I]; I++)
|
||
printLn(" .file %d \"%s\"", Files[I]->FileNo, Files[I]->Name);
|
||
|
||
// 计算局部变量的偏移量
|
||
assignLVarOffsets(Prog);
|
||
// 生成数据
|
||
emitData(Prog);
|
||
// 生成代码
|
||
emitText(Prog);
|
||
}
|