feat: plan for register allocation + temp fix for 'E' not being printed

include/codegen/fasm_stack.hpp

@@ -8,32 +8,36 @@ class StackFasmX86_64Generator : public CodeGenerator
 {
 public:
     ~StackFasmX86_64Generator() override = default;
+
 private:
     StringView GetTempAddr(IR::Value reg)
     {
         return std::move((StringBuilder() << reg.Format()).view());
     }
 
-    StringView GetSlotAddr(const IR::IRSlot& slot)
+    StringView GetSlotAddr(const IR::IRSlot &slot)
     {
         switch (slot.GetType())
         {
         case IR::IRSlot::Type::REGISTRY:
         {
             StringBuilder sb;
-            sb.AppendFormat("r%d", slot.GetSlot() + 10); // for r10, r11, r12 etc.
+            sb.AppendFormat("r%d", slot.GetSlot() + 12); // for r10, r11, r12 etc.
             return sb.view();
-        } break;
+        }
+        break;
         case IR::IRSlot::Type::STACK:
         {
             StringBuilder sb;
             sb.AppendFormat("[rbp-%d]", slot.GetSlot()); // for r10, r11, r12 etc.
             return sb.view();
-        } break;
+        }
+        break;
         default:
             assert(0 && "TODO: either unreachable or handle properly");
         }
     }
+
 private:
     void GenerateOp(const IR::Op *op)
     {
@@ -59,16 +63,16 @@ private:
             appendf("mov rbp, rsp\n");
 
             StringBuilder fnOutput;
-            StringBuilder* backup = m_output;
+            StringBuilder *backup = m_output;
             m_output = &fnOutput;
-            
+
             if (fn->params().size > 0)
             {
                 // TODO: support multiple parameters
                 auto param_slot = m_allocator->Allocate(fn->params().data[0]);
                 appendf("mov %s, rdi\n", GetSlotAddr(param_slot).c_str());
             }
-            for(auto &fOp : fn->body().ops())
+            for (auto &fOp : fn->body().ops())
             {
                 GenerateOp(fOp);
             }
@@ -135,11 +139,13 @@ private:
             appendf("mov %s, rax\n", GetSlotAddr(result_slot).c_str());
         }
         break;
-        default: appendf("; NOT HANDLED\n; %s\n", op->Format(0).c_str()); break;
+        default:
+            appendf("; NOT HANDLED\n; %s\n", op->Format(0).c_str());
+            break;
         }
     }
 
-    void appendf(const char * fmt, ...)
+    void appendf(const char *fmt, ...)
     {
         assert(m_output != nullptr && "nowhere to write");
         va_list args;
@@ -147,25 +153,29 @@ private:
         m_output->VAppendFormat(fmt, args);
         va_end(args);
     }
+
 public:
     StringView GetOutput() { return m_output->view(); }
+
 private:
-    StringBuilder* m_output = nullptr;
+    StringBuilder *m_output = nullptr;
+
 public:
-    void Generate(const char* filename, View<IR::Op*> ops) override
+    void Generate(const char *filename, View<IR::Op *> ops) override
     {
         m_output = new StringBuilder();
         appendf("; fasm x86_64 linux generated assembly using pl\n");
         appendf("format ELF64\n");
         appendf("section '.text' executable\n");
 
-        for (auto& op : ops)
+        for (auto &op : ops)
         {
             GenerateOp(op);
         }
     }
+
 public:
     // StackAllocator* m_stack = nullptr;
     // TODO: handle sub-blocks
-    SlotAllocator* m_allocator = nullptr;
+    SlotAllocator *m_allocator = nullptr;
 };