major refactoring;

CMakeLists.txt

@@ -25,8 +25,6 @@ add_library(city
         src/ir/Builder.h
         src/ir/instruction/IRInstruction.cpp
         src/ir/instruction/IRInstruction.h
-        src/backend/NativeModule.cpp
-        src/backend/NativeModule.h
         src/Assembly.cpp
         src/Assembly.h
         src/ir/value/ConstantValue.cpp
@@ -62,28 +60,30 @@ add_library(city
         src/ir/instruction/memory/StoreInst.cpp
         src/backend/amd64/Amd64.cpp
         src/backend/amd64/Amd64.h
-        src/backend/IRTranslator.h
         src/backend/amd64/Amd64Translator.cpp
         src/backend/amd64/Amd64Translator.h
         src/backend/amd64/instruction/Amd64Instruction.cpp
         src/backend/amd64/instruction/Amd64Instruction.h
-        src/backend/amd64/instruction/arithmetic/x86AddRM32Inst.h
+        src/backend/amd64/instruction/arithmetic/Amd64AddRM32Inst.h
         src/ByteBuffer.h
-        src/backend/amd64/instruction/arithmetic/x86AddMI32Inst.h
+        src/backend/amd64/instruction/arithmetic/Amd64AddMI32Inst.h
         src/ir/instruction/InstructionFunctor.h
         src/backend/NativeInstruction.cpp
         src/backend/NativeInstruction.h
         src/backend/amd64/Amd64Register.cpp
         src/backend/amd64/Amd64Register.h
         src/backend/amd64/Amd64ModRM.h
-        src/backend/amd64/instruction/memory/Amd64PushO64.h
-        src/backend/amd64/instruction/memory/Amd64MovMR64.h
-        src/backend/amd64/instruction/memory/Amd64PopO64.h
-        src/backend/amd64/instruction/control/Amd64RetZONear.h
+        src/backend/amd64/instruction/memory/Amd64Push.h
+        src/backend/amd64/instruction/memory/Amd64Mov.h
+        src/backend/amd64/instruction/memory/Amd64Pop.h
+        src/backend/amd64/instruction/control/Amd64Ret.h
         src/runtime/Windows.cpp
         src/runtime/Windows.h
         src/Object.cpp
         src/Object.h
+        src/backend/amd64/Amd64Module.cpp
+        src/backend/amd64/Amd64Module.h
+        src/backend/IRTranslator.h
 )
 target_include_directories(city PUBLIC src)
 

src/JIT.cpp

@@ -3,32 +3,20 @@
 
 using namespace city;
 
-void JIT::TranslateIRModules()
+void JIT::CompileIRModules()
 {
-    for (auto &module : this->ir_modules_)
+    for (auto &[name, module] : this->ir_modules_)
     {
-        auto native_module = this->backend_->BuildModule(module);
-        this->native_modules_.push_back(std::move(native_module));
+        this->objects_.insert({name, this->backend_->BuildModule(module)});
     }
 
     this->ir_modules_.clear();
 }
 
-void JIT::CompileNativeModules()
-{
-    for (auto &native_module : this->native_modules_)
-    {
-        auto object = Object::FromNativeModule(native_module);
-        this->objects_.push_back(std::move(object));
-    }
-
-    this->native_modules_.clear();
-}
-
 Assembly JIT::LinkObjects() const
 {
     std::size_t allocation_size = 0;
-    for (auto const &object : this->objects_)
+    for (auto const &[name, object] : this->objects_)
     {
         allocation_size += object.GetBinarySize();
     }
@@ -37,7 +25,7 @@ Assembly JIT::LinkObjects() const
     Assembly assembly{std::move(native_memory)};
 
     std::size_t object_insertion_offset = 0;
-    for (auto const &object : this->objects_)
+    for (auto const &[name, object] : this->objects_)
     {
         auto object_size = object.GetBinarySize();
 
@@ -47,10 +35,10 @@ Assembly JIT::LinkObjects() const
 
         object_insertion_offset += object_size;
 
-        for (auto &[name, offset] : object.symtab_)
+        for (auto &[name, offset] : object.symbol_table_)
         {
             assembly.symbol_table_[name] = {
-                    .raw = assembly_addr + offset,
+                    .location = assembly_addr + reinterpret_cast<std::size_t>(offset.location),
                     .flags = SymbolFlags::Exectuable,
             };
         }
@@ -61,17 +49,20 @@ Assembly JIT::LinkObjects() const
     return assembly;
 }
 
-void JIT::AddIRModule(IRModule module)
+void JIT::InsertIRModule(IRModule module)
 {
-    this->ir_modules_.push_back(std::move(module));
+    this->ir_modules_.insert({module.GetName(), std::move(module)});
 }
 
-void JIT::RemoveModule(std::string const &name) {}
+void JIT::RemoveModule(std::string const &name)
+{
+    this->ir_modules_.erase(name);
+    this->objects_.erase(name);
+}
 
 Assembly JIT::CompileAndLink()
 {
-    this->TranslateIRModules();
-    this->CompileNativeModules();
+    this->CompileIRModules();
 
     return this->LinkObjects();
 }

src/JIT.h

@@ -2,11 +2,11 @@
 #define CITY_COMPILER_H
 
 #include <memory>
+#include <unordered_map>
 #include <vector>
 #include "Assembly.h"
 #include "Object.h"
 #include "backend/Backend.h"
-#include "backend/NativeModule.h"
 #include "ir/IRModule.h"
 
 namespace city
@@ -15,19 +15,13 @@ namespace city
     {
         std::unique_ptr<Backend> backend_;
 
-        std::vector<IRModule> ir_modules_;
-        std::vector<NativeModule> native_modules_;
-        std::vector<Object> objects_;
+        std::unordered_map<std::string, IRModule> ir_modules_;
+        std::unordered_map<std::string, Object> objects_;
 
         /**
          * Translates all IR modules to native modules and deletes the IR modules.
          */
-        void TranslateIRModules();
-
-        /**
-         * Translates all native modules into objects and deletes the native modules.
-         */
-        void CompileNativeModules();
+        void CompileIRModules();
 
         /**
          * Links all objects together (non-destructively) and returns the final linked Assembly.
@@ -40,8 +34,13 @@ namespace city
          * Adds a module to the compiler, transferring ownership to the compiler.
          * @param module Module to transfer to the compiler
          */
-        void AddIRModule(IRModule module);
+        void InsertIRModule(IRModule module);
 
+        /**
+         * Removes a module (or corresponding object if already compiled) from the compiler.
+         * WARNING: May cause linker errors if other modules depend on the removed module.
+         * @param name Name of module to remove
+         */
         void RemoveModule(std::string const &name);
 
         /**

src/Object.cpp

@@ -7,34 +7,4 @@ std::size_t Object::GetBinarySize() const noexcept
     return this->native_memory_.GetAllocationSize();
 }
 
-Object Object::FromNativeModule(NativeModule const &module)
-{
-    // Allocate memory
-    std::size_t allocation_size = 0;
-    for (auto &inst : module.instructions_)
-    {
-        allocation_size += inst->GetBinarySize();
-    }
-    auto native_memory = NativeMemoryHandle::Allocate(allocation_size);
-
-    // Create object
-    Object object{std::move(native_memory)};
-
-    // Write to buffer
-    std::size_t offset = 0;
-    for (auto &inst : module.instructions_)
-    {
-        auto label = inst->GetLabel();
-        if (label != nullptr)
-        {
-            object.symtab_[label] = offset;
-        }
-
-        auto addr = object.native_memory_.GetAddressAtOffset(offset);
-        offset += inst->WriteToBuffer(addr);
-    }
-
-    return object;
-}
-
-Object::Object(NativeMemoryHandle native_memory) : native_memory_(std::move(native_memory)) {}
+Object::Object(NativeMemoryHandle &&native_memory, SymbolTable &&symbol_table) : native_memory_(std::move(native_memory)), symbol_table_(std::move(symbol_table)) {}

src/Object.h

@@ -1,9 +1,7 @@
 #ifndef OBJECT_H
 #define OBJECT_H
 
-#include <string>
-#include <unordered_map>
-#include "backend/NativeModule.h"
+#include "Symbol.h"
 #include "runtime/NativeMemoryHandle.h"
 
 namespace city
@@ -16,18 +14,12 @@ namespace city
 
     protected:
         NativeMemoryHandle native_memory_;
-
-        /**
-         * Holds instruction labels with their offsets into the binary.
-         */
-        std::unordered_map<std::string, std::size_t> symtab_;
+        SymbolTable symbol_table_;
 
     public:
         [[nodiscard]] std::size_t GetBinarySize() const noexcept;
 
-        static Object FromNativeModule(NativeModule const &module);
-
-        Object(NativeMemoryHandle native_memory);
+        Object(NativeMemoryHandle &&native_memory, SymbolTable &&symbol_table);
     };
 } // namespace city
 

src/Symbol.h

@@ -2,6 +2,8 @@
 #define CITY_SYMBOL_H
 
 #include <cstddef>
+#include <string>
+#include <unordered_map>
 
 namespace city
 {
@@ -12,15 +14,17 @@ namespace city
 
     struct Symbol
     {
-        std::byte *raw;
+        std::byte *location;
         SymbolFlags flags;
 
         template<typename T>
         T *ToPointer() const noexcept
         {
-            return reinterpret_cast<T *>(this->raw);
+            return reinterpret_cast<T *>(this->location);
         }
     };
+
+    using SymbolTable = std::unordered_map<std::string, Symbol>;
 } // namespace city
 
 #endif // CITY_SYMBOL_H

src/backend/Backend.h

@@ -1,15 +1,15 @@
 #ifndef CITY_BACKEND_H
 #define CITY_BACKEND_H
 
-#include "NativeModule.h"
+#include "Object.h"
 #include "ir/IRModule.h"
 
 namespace city
 {
     class Backend
     {
     public:
-        [[nodiscard]] virtual NativeModule BuildModule(IRModule &module) = 0;
+        [[nodiscard]] virtual Object BuildModule(IRModule &module) = 0;
 
         /**
          * Instantiates and returns a handle to the host-native compiler backend.

src/backend/IRTranslator.h

@@ -1,7 +1,6 @@
-#ifndef IRTRANSLATIONINTERFACE_H
-#define IRTRANSLATIONINTERFACE_H
+#ifndef IRTRANSLATOR_H
+#define IRTRANSLATOR_H
 
-#include "NativeModule.h"
 #include "ir/instruction/InstructionFunctor.h"
 
 namespace city
@@ -12,10 +11,7 @@ namespace city
 
     struct IRTranslator : InstructionFunctor<IRTranslationResult>
     {
-        NativeModule &module;
-
-        explicit IRTranslator(NativeModule &native_module) : module(native_module) {}
     };
 } // namespace city
 
-#endif // IRTRANSLATIONINTERFACE_H
+#endif // IRTRANSLATOR_H