lab3

CMakeLists.txt

@@ -39,6 +39,7 @@ INCLUDE_DIRECTORIES(
     include/cminusfc
     include/common
     include/lightir
+    include/codegen
     ${LLVM_INCLUDE_DIRS}
 )
 

include/codegen/ASMInstruction.hpp

+#pragma once
+
+#include <cassert>
+#include <string>
+
+struct ASMInstruction {
+    enum InstType { Instruction, Atrribute, Label, Comment } type;
+    std::string content;
+
+    explicit ASMInstruction(std::string s, InstType ty = Instruction)
+        : type(ty), content(s) {}
+
+    std::string format() const {
+        switch (type) {
+        case ASMInstruction::Instruction:
+        case ASMInstruction::Atrribute:
+            return "\t" + content + "\n";
+        case ASMInstruction::Label:
+            return content + ":\n";
+        case ASMInstruction::Comment:
+            return "# " + content + "\n";
+        }
+        assert(false && "unreachable");
+    }
+};

include/codegen/CodeGen.hpp

+#pragma once
+
+#include "ASMInstruction.hpp"
+#include "Module.hpp"
+#include "Register.hpp"
+
+class CodeGen {
+  public:
+    explicit CodeGen(Module *module) : m(module) {}
+
+    std::string print() const;
+
+    void run();
+
+    template <class... Args> void append_inst(Args... arg) {
+        output.emplace_back(arg...);
+    }
+
+    void
+    append_inst(const char *inst, std::initializer_list<std::string> args,
+                ASMInstruction::InstType ty = ASMInstruction::Instruction) {
+        auto content = std::string(inst) + " ";
+        for (const auto &arg : args) {
+            content += arg + ", ";
+        }
+        content.pop_back();
+        content.pop_back();
+        output.emplace_back(content, ty);
+    }
+
+  private:
+    void allocate();
+    void copy_stmt(); // for phi copy
+
+    // 向寄存器中装载数据
+    void load_to_greg(Value *, const Reg &);
+    void load_to_freg(Value *, const FReg &);
+    void load_from_stack_to_greg(Value *, const Reg &);
+
+    // 向寄存器中加载立即数
+    void load_large_int32(int32_t, const Reg &);
+    void load_large_int64(int64_t, const Reg &);
+    void load_float_imm(float, const FReg &);
+
+    // 将寄存器中的数据保存回栈上
+    void store_from_greg(Value *, const Reg &);
+    void store_from_freg(Value *, const FReg &);
+
+    void gen_prologue();
+    void gen_ret();
+    void gen_br();
+    void gen_binary();
+    void gen_float_binary();
+    void gen_alloca();
+    void gen_load();
+    void gen_store();
+    void gen_icmp();
+    void gen_fcmp();
+    void gen_zext();
+    void gen_call();
+    void gen_gep();
+    void gen_sitofp();
+    void gen_fptosi();
+    void gen_epilogue();
+
+    static std::string label_name(BasicBlock *bb) {
+        return "." + bb->get_parent()->get_name() + "_" + bb->get_name();
+    }
+
+    static std::string func_exit_label_name(Function *func) {
+        return func->get_name() + "_exit";
+    }
+
+    static std::string fcmp_label_name(BasicBlock *bb, unsigned cnt) {
+        return label_name(bb) + "_fcmp_" + std::to_string(cnt);
+    }
+
+    struct {
+        /* 随着ir遍历设置 */
+        Function *func{nullptr};    // 当前函数
+        BasicBlock *bb{nullptr};    // 当前基本块
+        Instruction *inst{nullptr}; // 当前指令
+        /* 在allocate()中设置 */
+        unsigned frame_size{0}; // 当前函数的栈帧大小
+        std::unordered_map<Value *, int> offset_map{}; // 指针相对 fp 的偏移
+        unsigned fcmp_cnt{0}; // fcmp 的计数器, 用于创建 fcmp 需要的 label
+
+        void clear() {
+            func = nullptr;
+            bb = nullptr;
+            inst = nullptr;
+            frame_size = 0;
+            fcmp_cnt = 0;
+            offset_map.clear();
+        }
+
+    } context;
+
+    Module *m;
+    std::list<ASMInstruction> output;
+};

include/codegen/CodeGenUtil.hpp

+#pragma once
+
+#include <stdexcept>
+
+/* 关于位宽 */
+#define IMM_12_MAX 0x7FF
+#define IMM_12_MIN -0x800
+
+#define LOW_12_MASK 0x00000FFF
+#define LOW_20_MASK 0x000FFFFF
+#define LOW_32_MASK 0xFFFFFFFF
+
+inline unsigned ALIGN(unsigned x, unsigned alignment) {
+    return ((x + (alignment - 1)) & ~(alignment - 1));
+}
+
+inline bool IS_IMM_12(int x) { return x <= IMM_12_MAX and x >= IMM_12_MIN; }
+
+/* 栈帧相关 */
+#define PROLOGUE_OFFSET_BASE 16 // $ra $fp
+#define PROLOGUE_ALIGN 16
+
+/* 龙芯指令 */
+// Arithmetic
+#define ADD "add"
+#define SUB "sub"
+#define MUL "mul"
+#define DIV "div"
+
+#define ADDI "addi"
+
+#define FADD "fadd"
+#define FSUB "fsub"
+#define FMUL "fmul"
+#define FDIV "fdiv"
+
+#define ORI "ori"
+
+#define LU12I_W "lu12i.w"
+#define LU32I_D "lu32i.d"
+#define LU52I_D "lu52i.d"
+
+// Data transfer (greg <-> freg)
+#define GR2FR "movgr2fr"
+#define FR2GR "movfr2gr"
+
+// Memory access
+#define LOAD "ld"
+#define STORE "st"
+#define FLOAD "fld"
+#define FSTORE "fst"
+
+#define BYTE ".b"
+#define HALF_WORD ".h"
+#define WORD ".w"
+#define DOUBLE ".d"
+
+#define SINGLE ".s" // float
+#define LONG ".l"
+
+// ASM syntax sugar
+#define LOAD_ADDR "la.local"
+
+// errors
+class not_implemented_error : public std::logic_error {
+  public:
+    explicit not_implemented_error(std::string &&err_msg = "")
+        : std::logic_error(err_msg){};
+};
+
+class unreachable_error : public std::logic_error {
+  public:
+    explicit unreachable_error(std::string &&err_msg = "")
+        : std::logic_error(err_msg){};
+};

include/codegen/Register.hpp

+#pragma once
+
+#include <cassert>
+#include <string>
+
+/* General-purpose Register Convention:
+ * Name         Alias       Meaning
+ * $r0          $zero       constant 0
+ * $r1          $ra         return address
+ * $r2          $tp         thread pointer
+ * $r3          $sp         stack pointer
+ * $r4 - $r5    $a0 - $a1   argument, return value
+ * $r6 - $r11   $a2 - $a7   argument
+ * $r12 - $r20  $t0 - $t8   temporary
+ * $r21                     saved
+ * $r22         $fp / $s9   frame pointer
+ * $r23 - $r31  $s0 - $s8   static
+ *
+ * Floating-point Register Convention
+ * Name	        Alias	    Meaning
+ * $f0-$f1      $fa0-$fa1   argument/return value
+ * $f2-$f7      $fa2-$fa7   argument
+ * $f8-$f23     $ft0-$ft15  temporary
+ * $f24-$f31    $fs0-$fs7   static
+ */
+
+struct Reg {
+    unsigned id;
+
+    explicit Reg(unsigned i) : id(i) { assert(i <= 31); }
+    bool operator==(const Reg &other) { return id == other.id; }
+
+    std::string print() const;
+
+    static Reg zero() { return Reg(0); }
+    static Reg ra() { return Reg(1); }
+    static Reg sp() { return Reg(3); }
+    static Reg fp() { return Reg(22); }
+    static Reg a(unsigned i) {
+        assert(0 <= i and i <= 7);
+        return Reg(i + 4);
+    }
+    static Reg t(unsigned i) {
+        assert(0 <= i and i <= 8);
+        return Reg(i + 12);
+    }
+    static Reg s(unsigned i) {
+        assert(0 <= i and i <= 9);
+        if (i == 9)
+            return Reg(22);
+        else
+            return Reg(i + 23);
+    }
+};
+
+struct FReg {
+    unsigned id;
+
+    explicit FReg(unsigned i) : id(i) { assert(i <= 31); }
+    bool operator==(const FReg &other) { return id == other.id; }
+
+    std::string print() const;
+
+    static FReg fa(unsigned i) {
+        assert(0 <= i and i <= 7);
+        return FReg(i);
+    }
+    static FReg ft(unsigned i) {
+        assert(0 <= i and i <= 15);
+        return FReg(i + 8);
+    }
+    static FReg fs(unsigned i) {
+        assert(0 <= i and i <= 7);
+        return FReg(i + 24);
+    }
+};
+
+struct CFReg {
+    unsigned id;
+
+    explicit CFReg(unsigned i) : id(i) { assert(i <= 7); }
+    bool operator==(const CFReg &other) { return id == other.id; }
+
+    std::string print() const { return "$fcc" + std::to_string(id); }
+};

src/CMakeLists.txt

@@ -4,3 +4,4 @@ add_subdirectory(logging)
 add_subdirectory(cminusfc)
 add_subdirectory(lightir)
 add_subdirectory(io)
+add_subdirectory(codegen)
\ No newline at end of file

src/cminusfc/CMakeLists.txt

@@ -8,6 +8,7 @@ target_link_libraries(
     cminusfc
     IR_lib
     common
+    codegen
     syntax
     stdc++fs
 )

src/cminusfc/main.cpp

 #include "Module.hpp"
 #include "ast.hpp"
 #include "cminusf_builder.hpp"
+#include "CodeGen.hpp"
 
 #include <filesystem>
 #include <fstream>
@@ -16,6 +17,7 @@ struct Config {
     std::filesystem::path output_file;
 
     bool emitast{false};
+    bool emitasm{false};
     bool emitllvm{false};
 
     Config(int argc, char **argv) : argc(argc), argv(argv) {
@@ -55,9 +57,13 @@ int main(int argc, char **argv) {
             output_stream << "; ModuleID = 'cminus'\n";
             output_stream << "source_filename = " << abs_path << "\n\n";
             output_stream << m->print();
+        } else if (config.emitasm) {
+            CodeGen codegen(m.get());
+            codegen.run();
+            output_stream << codegen.print();
         }
 
-        // TODO: lab3 lab4 (IR optimization or codegen)
+        // TODO: lab4 (IR optimization or codegen)
     }
 
     return 0;
@@ -77,6 +83,8 @@ void Config::parse_cmd_line() {
             }
         } else if (argv[i] == "-emit-ast"s) {
             emitast = true;
+        } else if (argv[i] == "-S"s) {
+            emitasm = true;
         } else if (argv[i] == "-emit-llvm"s) {
             emitllvm = true;
         } else {
@@ -105,7 +113,7 @@ void Config::check() {
 
 void Config::print_help() const {
     std::cout << "Usage: " << exe_name
-              << " [-h|--help] [-o <target-file>] [-mem2reg] [-emit-llvm] [-S] "
+              << " [-h|--help] [-o <target-file>] [-emit-ast] [-emit-llvm] [-S] "
                  "<input-file>"
               << std::endl;
     exit(0);

src/codegen/CMakeLists.txt

+add_library(
+    codegen STATIC
+    CodeGen.cpp
+    Register.cpp
+)
+
+target_link_libraries(codegen common IR_lib)

src/codegen/Register.cpp

+#include "Register.hpp"
+#include <string>
+
+std::string Reg::print() const {
+    if (id == 0) {
+        return "$zero";
+    }
+    if (id == 1) {
+        return "$ra";
+    }
+    if (id == 2) {
+        return "$tp";
+    }
+    if (id == 3) {
+        return "$sp";
+    }
+    if (4 <= id and id <= 11) {
+        return "$a" + std::to_string(id - 4);
+    }
+    if (12 <= id and id <= 20) {
+        return "$t" + std::to_string(id - 12);
+    }
+    if (id == 22) {
+        return "$fp";
+    }
+    assert(false);
+}
+
+std::string FReg::print() const {
+
+    if (0 <= id and id <= 7) {
+        return "$fa" + std::to_string(id);
+    }
+    if (8 <= id and id <= 23) {
+        return "$ft" + std::to_string(id - 8);
+    }
+    if (24 <= id and id <= 31) {
+        return "$fs" + std::to_string(id - 24);
+    }
+    assert(false);
+}