Trans Codegen - Structure coming up

1 files changed, 262 insertions, 0 deletions

diff --git a/src/trans/monomorphise.cpp b/src/trans/monomorphise.cpp
new file mode 100644
index 00000000..bca5ce14
--- /dev/null
+++ b/src/trans/monomorphise.cpp
@@ -0,0 +1,262 @@
+/*
+ * MRustC - Rust Compiler
+ * - By John Hodge (Mutabah/thePowersGang)
+ *
+ * trans/monomorphise.hpp
+ * - MIR monomorphisation
+ */
+#include "monomorphise.hpp"
+#include <mir/mir.hpp>
+
+
+namespace {
+    ::MIR::LValue monomorph_LValue(const ::HIR::Crate& crate, const Trans_Params& params, const ::MIR::LValue& tpl)
+    {
+        TU_MATCHA( (tpl), (e),
+        (Variable,  return e; ),
+        (Temporary, return e; ),
+        (Argument,  return e; ),
+        (Return, return e; ),
+        (Static,
+            return params.monomorph(crate, e);
+            ),
+        (Field,
+            return ::MIR::LValue::make_Field({
+                box$(monomorph_LValue(crate, params, *e.val)),
+                e.field_index
+                });
+            ),
+        (Deref,
+            return ::MIR::LValue::make_Deref({
+                box$(monomorph_LValue(crate, params, *e.val))
+                });
+            ),
+        (Index,
+            return ::MIR::LValue::make_Index({
+                box$(monomorph_LValue(crate, params, *e.val)),
+                box$(monomorph_LValue(crate, params, *e.idx))
+                });
+            ),
+        (Downcast,
+            return ::MIR::LValue::make_Field({
+                box$(monomorph_LValue(crate, params, *e.val)),
+                e.variant_index
+                });
+            )
+        )
+        throw "";
+    }
+    ::std::vector<::MIR::LValue> monomorph_LValue_list(const ::HIR::Crate& crate, const Trans_Params& params, const ::std::vector<::MIR::LValue>& tpl)
+    {
+        ::std::vector<::MIR::LValue>    rv;
+        rv.reserve( tpl.size() );
+        for(const auto& v : tpl)
+            rv.push_back( monomorph_LValue(crate, params, v) );
+        return rv;
+    }
+}
+
+::MIR::FunctionPointer Trans_Monomorphise(const ::HIR::Crate& crate, const Trans_Params& params, const ::MIR::FunctionPointer& tpl)
+{
+    static Span sp;
+    TRACE_FUNCTION;
+    
+    ::MIR::Function output;
+    
+    // 1. Monomorphise locals and temporaries
+    output.named_variables.reserve( tpl->named_variables.size() );
+    for(const auto& var : tpl->named_variables)
+    {
+        output.named_variables.push_back( params.monomorph(crate, var) );
+    }
+    output.temporaries.reserve( tpl->temporaries.size() );
+    for(const auto& ty : tpl->temporaries)
+    {
+        output.named_variables.push_back( params.monomorph(crate, ty) );
+    }
+    
+    // 2. Monomorphise all paths
+    // 3. Convert virtual dispatch to vtable load
+    output.blocks.reserve( tpl->blocks.size() );
+    for(const auto& block : tpl->blocks)
+    {
+        ::std::vector< ::MIR::Statement>    statements;
+        
+        statements.reserve( block.statements.size() );
+        for(const auto& stmt : block.statements)
+        {
+            assert( stmt.is_Drop() || stmt.is_Assign() );
+            if( stmt.is_Drop() )
+            {
+                const auto& e = stmt.as_Drop();
+                statements.push_back( ::MIR::Statement::make_Drop({
+                    e.kind,
+                    monomorph_LValue(crate, params, e.slot)
+                    }) );
+            }
+            else
+            {
+                const auto& e = stmt.as_Assign();
+                
+                ::MIR::RValue   rval;
+                TU_MATCHA( (e.src), (se),
+                (Use,
+                    rval = ::MIR::RValue( monomorph_LValue(crate, params, se) );
+                    ),
+                (Constant,
+                    TU_MATCHA( (se), (ce),
+                    (Int,
+                        rval = ::MIR::Constant::make_Int(ce);
+                        ),
+                    (Uint,
+                        rval = ::MIR::Constant::make_Uint(ce);
+                        ),
+                    (Float,
+                        rval = ::MIR::Constant::make_Float(ce);
+                        ),
+                    (Bool,
+                        rval = ::MIR::Constant::make_Bool(ce);
+                        ),
+                    (Bytes,
+                        rval = ::MIR::Constant(ce);
+                        ),
+                    (StaticString,
+                        rval = ::MIR::Constant(ce);
+                        ),
+                    (Const,
+                        rval = ::MIR::Constant::make_Const({
+                            params.monomorph(crate, ce.p)
+                            });
+                        ),
+                    (ItemAddr,
+                        auto p = params.monomorph(crate, ce);
+                        // TODO: If this is a pointer to a function on a trait object, replace with the address loaded from the vtable.
+                        // - Requires creating a new temporary for the vtable pointer.
+                        rval = ::MIR::Constant( mv$(p) );
+                        )
+                    )
+                    ),
+                (SizedArray,
+                    rval = ::MIR::RValue::make_SizedArray({
+                        monomorph_LValue(crate, params, se.val),
+                        se.count
+                        });
+                    ),
+                (Borrow,
+                    rval = ::MIR::RValue::make_Borrow({
+                        se.region, se.type,
+                        monomorph_LValue(crate, params, se.val)
+                        });
+                    ),
+                (Cast,
+                    rval = ::MIR::RValue::make_Cast({
+                        monomorph_LValue(crate, params, se.val),
+                        params.monomorph(crate, se.type)
+                        });
+                    ),
+                (BinOp,
+                    rval = ::MIR::RValue::make_BinOp({
+                        monomorph_LValue(crate, params, se.val_l),
+                        se.op,
+                        monomorph_LValue(crate, params, se.val_r)
+                        });
+                    ),
+                (UniOp,
+                    rval = ::MIR::RValue::make_UniOp({
+                        monomorph_LValue(crate, params, se.val),
+                        se.op
+                        });
+                    ),
+                (DstMeta,
+                    auto lv = monomorph_LValue(crate, params, se.val);
+                    // TODO: Get the type of this, and if it's an array - replace with the size
+                    rval = ::MIR::RValue::make_DstMeta({ mv$(lv) });
+                    ),
+                (DstPtr,
+                    rval = ::MIR::RValue::make_DstPtr({ monomorph_LValue(crate, params, se.val) });
+                    ),
+                (MakeDst,
+                    rval = ::MIR::RValue::make_MakeDst({
+                        monomorph_LValue(crate, params, se.ptr_val),
+                        monomorph_LValue(crate, params, se.meta_val)
+                        });
+                    ),
+                (Tuple,
+                    rval = ::MIR::RValue::make_Tuple({
+                        monomorph_LValue_list(crate, params, se.vals)
+                        });
+                    ),
+                (Array,
+                    rval = ::MIR::RValue::make_Array({
+                        monomorph_LValue_list(crate, params, se.vals)
+                        });
+                    ),
+                // Create a new instance of a union (and eventually enum)
+                (Variant,
+                    rval = ::MIR::RValue::make_Variant({
+                        params.monomorph(crate, se.path),
+                        se.index,
+                        monomorph_LValue(crate, params, se.val)
+                        });
+                    ),
+                // Create a new instance of a struct (or enum)
+                (Struct,
+                    rval = ::MIR::RValue::make_Struct({
+                        params.monomorph(crate, se.path),
+                        monomorph_LValue_list(crate, params, se.vals)
+                        });
+                    )
+                )
+                
+                statements.push_back( ::MIR::Statement::make_Assign({
+                    monomorph_LValue(crate, params, e.dst),
+                    mv$(rval)
+                    }) );
+            }
+        }
+        
+        ::MIR::Terminator   terminator;
+        
+        TU_MATCHA( (block.terminator), (e),
+        (Incomplete,
+            BUG(sp, "Incomplete block");
+            ),
+        (Return,
+            terminator = e;
+            ),
+        (Diverge,
+            terminator = e;
+            ),
+        (Goto,
+            terminator = e;
+            ),
+        (Panic,
+            terminator = e;
+            ),
+        (If,
+            terminator = ::MIR::Terminator::make_If({
+                monomorph_LValue(crate, params, e.cond),
+                e.bb0, e.bb1
+                });
+            ),
+        (Switch,
+            terminator = ::MIR::Terminator::make_Switch({
+                monomorph_LValue(crate, params, e.val),
+                e.targets
+                });
+            ),
+        (Call,
+            terminator = ::MIR::Terminator::make_Call({
+                e.ret_block, e.panic_block,
+                monomorph_LValue(crate, params, e.ret_val),
+                monomorph_LValue(crate, params, e.fcn_val),
+                monomorph_LValue_list(crate, params, e.args)
+                });
+            )
+        )
+        
+        output.blocks.push_back( ::MIR::BasicBlock { mv$(statements), mv$(terminator) } );
+    }
+    
+    return ::MIR::FunctionPointer( box$(output).release() );
+}