New idea

CMakeLists.txt

@@ -1,4 +0,0 @@
-cmake_minimum_required(VERSION 3.11)
-
-# Add subproject
-ADD_SUBDIRECTORY(src)

src/.clang-format

@@ -1,7 +0,0 @@
----
-BasedOnStyle: WebKit
-BreakBeforeBraces: Allman
-ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
-UseTab: Never
-
-...

src/CMakeLists.txt

@@ -1,7 +0,0 @@
-cmake_minimum_required(VERSION 3.11)
-
-ADD_COMPILE_OPTIONS("/std:c++latest")
-
-# Add subproject
-ADD_SUBDIRECTORY(natsuclr)
-ADD_SUBDIRECTORY(tests)

src/Natsu/Natsu.Compiler/Natsu.Compiler.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="dnlib" Version="3.2.0" />
+  </ItemGroup>
+
+</Project>

src/Natsu/Natsu.Compiler/Program.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using dnlib.DotNet;
+
+namespace Natsu.Compiler
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            var fileName = @"..\System.Private.CorLib\bin\Debug\netstandard2.0\System.Private.CorLib.dll";
+            var module = ModuleDefMD.Load(fileName);
+            var generator = new Generator(module);
+            generator.Generate();
+        }
+    }
+
+    class Generator
+    {
+        private readonly ModuleDefMD _module;
+
+        public Generator(ModuleDefMD module)
+        {
+            _module = module;
+        }
+
+        public void Generate()
+        {
+            var moduleDesc = new ModuleDesc(_module);
+            var namespaces = new List<NamespaceDesc>();
+            NamespaceDesc GetOrAddNamespace(UTF8String name)
+            {
+                var desc = new NamespaceDesc
+                {
+                    Name = name,
+                    QualifiedName =}
+            }
+
+            foreach (var type in _module.Types)
+            {
+                var ns = GetOrAddNamespace(type.Namespace);
+            }
+        }
+
+        class ModuleDesc
+        {
+            public string Name { get; }
+
+            public ModuleDesc(ModuleDefMD module)
+            {
+                Name = module.Name.Replace('.', '_');
+            }
+        }
+
+        class NamespaceDesc
+        {
+            public string Name { get; }
+
+            public string QualifiedName { get; }
+
+            public Dictionary<UTF8String, NamespaceDesc> Nested { get; } = new Dictionary<UTF8String, NamespaceDesc>();
+
+            public NamespaceDesc(ModuleDesc module, UTF8String name, NamespaceDesc parent = null)
+            {
+                if (name.Contains("."))
+                    throw new ArgumentException("Namespace id is invalid: " + name);
+                Name = name;
+
+                if (parent != null)
+                    QualifiedName = parent.QualifiedName + "::" + Name;
+                else
+                    QualifiedName = "::" + module.Name + Name;
+            }
+        }
+
+        class TypeDesc
+        {
+            public UTF8String Name { get; set; }
+
+            public string QualifiedName { get; set; }
+
+            public Dictionary<UTF8String, TypeDesc> Nested { get; } = new Dictionary<UTF8String, TypeDesc>();
+        }
+    }
+}

src/Natsu/Natsu.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.29021.104
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Natsu.Compiler", "Natsu.Compiler\Natsu.Compiler.csproj", "{AC6248DB-5117-4C47-A3E7-D0B7E6258F6B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CorLib", "..\System.Private.CorLib\System.Private.CorLib.csproj", "{84230461-4F26-4EDD-AAFE-402C7FABD071}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{AC6248DB-5117-4C47-A3E7-D0B7E6258F6B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{AC6248DB-5117-4C47-A3E7-D0B7E6258F6B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{AC6248DB-5117-4C47-A3E7-D0B7E6258F6B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{AC6248DB-5117-4C47-A3E7-D0B7E6258F6B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{84230461-4F26-4EDD-AAFE-402C7FABD071}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{84230461-4F26-4EDD-AAFE-402C7FABD071}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{84230461-4F26-4EDD-AAFE-402C7FABD071}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{84230461-4F26-4EDD-AAFE-402C7FABD071}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {429BE0BD-F176-4959-97F3-6F657A877050}
+	EndGlobalSection
+EndGlobal

src/System.Private.CorLib/System.Private.CorLib.csproj.user

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <ProjectView>ProjectFiles</ProjectView>
-    <ShowAllFiles>false</ShowAllFiles>
-  </PropertyGroup>
-</Project>

src/System.Private.CorLib/System.Private.CorLib.sln

@@ -1,25 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27703.2026
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Private.CorLib", "System.Private.CorLib.csproj", "{0D306948-EF8B-4E69-AFAF-9FD3B09D1C30}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{0D306948-EF8B-4E69-AFAF-9FD3B09D1C30}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{0D306948-EF8B-4E69-AFAF-9FD3B09D1C30}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{0D306948-EF8B-4E69-AFAF-9FD3B09D1C30}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{0D306948-EF8B-4E69-AFAF-9FD3B09D1C30}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {7579A2D2-5B69-47B6-93FC-63030748002C}
-	EndGlobalSection
-EndGlobal

src/natsuclr/CMakeLists.txt

@@ -1,9 +0,0 @@
-INCLUDE_DIRECTORIES(include)
-
-FILE(GLOB_RECURSE TESTS_SRC "*.c" "*.cpp")
-
-ADD_LIBRARY(natsuclr STATIC ${TESTS_SRC})
-
-TARGET_LINK_LIBRARIES(natsuclr)
-SET_TARGET_PROPERTIES(natsuclr PROPERTIES
-							LINKER_LANGUAGE CXX)

src/natsuclr/binder/Binder.cpp

@@ -1,39 +0,0 @@
-//
-// Natsu CLR Binder
-//
-#include <binder/Binder.hpp>
-#include <cstring>
-
-using namespace clr;
-using namespace clr::loader;
-using namespace clr::vm;
-
-Binder::Binder(std::shared_ptr<AssemblyLoader> assemblyLoader)
-    : assemblyLoader_(assemblyLoader)
-{
-}
-
-vm::MethodDesc* Binder::BindMethod(std::string_view typeNameSpace, std::string_view typeName, std::string_view methodName)
-{
-    if (auto type = BindType(typeNameSpace, typeName))
-    {
-        for (auto mit = type->FirstMethod; mit != type->LastMethod; ++mit)
-        {
-            if (mit->Name == methodName)
-                return mit;
-        }
-    }
-
-    return nullptr;
-}
-
-vm::EEClass* Binder::BindType(std::string_view typeNameSpace, std::string_view typeName)
-{
-    for (auto& type : assemblyLoader_->GetClasses())
-    {
-        if (type.TypeNamespace == typeNameSpace && type.TypeName == typeName)
-            return &type;
-    }
-
-    return nullptr;
-}

src/natsuclr/binder/CorlibBinder.cpp

@@ -1,40 +0,0 @@
-//
-// Natsu CLR Binder
-//
-#include <binder/CorlibBinder.hpp>
-#include <string_view>
-
-using namespace std::string_view_literals;
-using namespace clr;
-using namespace clr::loader;
-using namespace clr::vm;
-
-static std::unique_ptr<CorlibBinder> corlibBinder_;
-
-CorlibBinder& CorlibBinder::Current()
-{
-    return *corlibBinder_;
-}
-
-void CorlibBinder::Initialize(std::shared_ptr<loader::AssemblyLoader> corlibAssemblyLoader)
-{
-    corlibBinder_.reset(new CorlibBinder(corlibAssemblyLoader));
-}
-
-#define MAKE_STR(name) #name
-#define MAKE_SV(name) MAKE_STR(name)##sv
-#define INIT_TYPE(ns, typeName) Types.typeName = BindType(MAKE_SV(ns), MAKE_SV(typeName))
-#define INIT_SYS_TYPE(typeName) INIT_TYPE(System, typeName)
-
-CorlibBinder::CorlibBinder(std::shared_ptr<loader::AssemblyLoader> assemblyLoader)
-    : Binder(assemblyLoader)
-{
-    INIT_SYS_TYPE(Boolean);
-    INIT_SYS_TYPE(Double);
-    INIT_SYS_TYPE(Int16);
-    INIT_SYS_TYPE(Int32);
-    INIT_SYS_TYPE(Object);
-    INIT_SYS_TYPE(Single);
-    INIT_SYS_TYPE(UInt32);
-    INIT_SYS_TYPE(Void);
-}

src/natsuclr/classlibnative/System/Array.cpp

@@ -1,30 +0,0 @@
-//
-// Natsu CLR Class Lib Native
-//
-#include <cassert>
-#include <classlibnative/System/Array.hpp>
-#include <stdio.h>
-
-using namespace clr;
-using namespace clr::corlib;
-
-long Array::get_LongLength(ObjectRef<Array> this_)
-{
-    return this_->length_;
-}
-
-int Array::GetLength(ObjectRef<Array> this_, int dimension)
-{
-    assert(dimension == 0);
-    return (int)this_->length_;
-}
-
-int Array::get_Rank(ObjectRef<Array> this_)
-{
-    return 1;
-}
-
-int Array::get_Length(ObjectRef<Array> this_)
-{
-    return (int)this_->length_;
-}

src/natsuclr/classlibnative/System/Console.cpp

@@ -1,14 +0,0 @@
-//
-// Natsu CLR Class Lib Native
-//
-#include <classlibnative/System/Console.hpp>
-#include <stdio.h>
-
-using namespace clr;
-using namespace clr::corlib;
-
-void Console::SayHello(int obj)
-{
-	printf("%d\n", obj);
-	//printf("Say Hello %s\n", obj->GetHeader().Class->TypeName);
-}

src/natsuclr/classlibnative/System/Object.cpp

@@ -1,19 +0,0 @@
-//
-// Natsu CLR Class Lib Native
-//
-#include <classlibnative/System/Object.hpp>
-#include <cassert>
-
-using namespace clr;
-using namespace clr::corlib;
-
-ObjectHeader& Object::GetHeader() noexcept
-{
-    return *reinterpret_cast<ObjectHeader*>(uintptr_t(this) - sizeof(ObjectHeader));
-}
-
-uintptr_t Object::GetType(ObjectRef<> this_)
-{
-    assert(false);
-    return 0;
-}

src/natsuclr/gc/gc.cpp

@@ -1,42 +0,0 @@
-//
-// Natsu CLR VM
-//
-#include <cassert>
-#include <gc/gc.hpp>
-#include <utils.hpp>
-
-using namespace clr;
-using namespace clr::corlib;
-using namespace clr::gc;
-using namespace clr::vm;
-using namespace clr::metadata;
-
-GC& GC::Current()
-{
-    static GC gc;
-    return gc;
-}
-
-GC::GC()
-{
-}
-
-ObjectRef<> GC::AllocateObject(EEClass* cls)
-{
-    assert(cls->LoadLevel >= clsLoad_InstanceFields);
-    auto size = sizeof(ObjectHeader) + cls->InstanceSize;
-    auto header = reinterpret_cast<ObjectHeader*>(new char[size]());
-    header->Class = cls;
-    return ObjectRef<>(reinterpret_cast<Object*>(uintptr_t(header) + sizeof(ObjectHeader)));
-}
-
-corlib::ObjectRef<Array> GC::AllocateArray(vm::EEClass* cls, uint64_t length)
-{
-    assert(cls->LoadLevel >= clsLoad_InstanceFields);
-    auto size = sizeof(ObjectHeader) + sizeof(Array) + align(cls->InstanceSize, cls->Align) * length;
-    auto header = reinterpret_cast<ObjectHeader*>(new char[size]());
-    header->Class = cls;
-    auto arr = ObjectRef<Array>(reinterpret_cast<Array*>(uintptr_t(header) + sizeof(ObjectHeader)));
-    arr->length_ = length;
-    return arr;
-}

src/natsuclr/include/binder/Binder.hpp

@@ -1,22 +0,0 @@
-//
-// Natsu CLR Binder
-//
-#pragma once
-#include "../loader/AssemblyLoader.hpp"
-#include <string_view>
-#include <optional>
-
-namespace clr
-{
-class Binder
-{
-public:
-    Binder(std::shared_ptr<loader::AssemblyLoader> assemblyLoader);
-
-    vm::MethodDesc* BindMethod(std::string_view typeNameSpace, std::string_view typeName, std::string_view methodName);
-    vm::EEClass* BindType(std::string_view typeNameSpace, std::string_view typeName);
-
-private:
-    std::shared_ptr<loader::AssemblyLoader> assemblyLoader_;
-};
-}

src/natsuclr/include/binder/CorlibBinder.hpp

@@ -1,40 +0,0 @@
-//
-// Natsu CLR Binder
-//
-#pragma once
-#include "Binder.hpp"
-
-namespace clr
-{
-struct MethodSig
-{
-    vm::TypeDesc* Types;
-    size_t TypesCount;
-};
-
-class CorlibBinder : public Binder
-{
-public:
-    static CorlibBinder& Current();
-    static void Initialize(std::shared_ptr<loader::AssemblyLoader> corlibAssemblyLoader);
-
-    struct
-    {
-        vm::EEClass* Boolean;
-        vm::EEClass* Double;
-        vm::EEClass* Int16;
-        vm::EEClass* Int32;
-        vm::EEClass* Object;
-        vm::EEClass* Single;
-        vm::EEClass* UInt32;
-        vm::EEClass* Void;
-    } Types;
-
-    struct
-    {
-    } MethodSigs;
-
-private:
-    CorlibBinder(std::shared_ptr<loader::AssemblyLoader> assemblyLoader);
-};
-}

src/natsuclr/include/classlibnative/System/Array.hpp

@@ -1,30 +0,0 @@
-//
-// Natsu CLR Class Lib Native
-//
-#pragma once
-#include "Object.hpp"
-
-namespace clr
-{
-namespace corlib
-{
-    class Array : public Object
-    {
-    public:
-        static long get_LongLength(ObjectRef<Array> this_);
-        static int GetLength(ObjectRef<Array> this_, int dimension);
-        static int get_Rank(ObjectRef<Array> this_);
-        static int get_Length(ObjectRef<Array> this_);
-
-        template <typename T>
-        T& At(uint64_t index) noexcept
-        {
-            auto cls = GetHeader().Class;
-            auto offset = uintptr_t(this) + sizeof(Array) + align(cls->InstanceSize, cls->Align) * index;
-            return *reinterpret_cast<T*>(offset);
-        }
-
-        uint64_t length_;
-    };
-}
-}

src/natsuclr/include/classlibnative/System/Console.hpp

@@ -1,17 +0,0 @@
-//
-// Natsu CLR Class Lib Native
-//
-#pragma once
-#include "Object.hpp"
-
-namespace clr
-{
-namespace corlib
-{
-    class Console
-    {
-    public:
-        static void SayHello(int obj);
-    };
-}
-}

src/natsuclr/include/classlibnative/System/Object.hpp

@@ -1,49 +0,0 @@
-//
-// Natsu CLR Class Lib Native
-//
-#pragma once
-#include "../../vm/EEClass.hpp"
-
-namespace clr
-{
-namespace corlib
-{
-    class Object;
-
-    struct ObjectHeader
-    {
-        vm::EEClass* Class;
-    };
-
-    template <class T = Object>
-    class ObjectRef
-    {
-    public:
-        explicit ObjectRef(T* ptr)
-            : ptr_(ptr)
-        {
-        }
-
-        T* Get() const noexcept
-        {
-            return ptr_;
-        }
-
-        T* operator->() const noexcept
-        {
-            return Get();
-        }
-
-    private:
-        T* ptr_;
-    };
-
-    class Object
-    {
-    public:
-        ObjectHeader& GetHeader() noexcept;
-
-        static uintptr_t GetType(ObjectRef<> this_);
-    };
-}
-}

src/natsuclr/include/gc/gc.hpp

@@ -1,41 +0,0 @@
-//
-// Natsu CLR GC
-//
-#pragma once
-#include "../classlibnative/System/Object.hpp"
-#include "../classlibnative/System/Array.hpp"
-#include <vector>
-
-namespace clr
-{
-namespace gc
-{
-    class GCHeap
-    {
-    public:
-        GCHeap(size_t size);
-
-        corlib::ObjectRef<> AllocateObject(vm::EEClass* cls);
-        void Collect();
-    private:
-        std::unique_ptr<uint8_t[]> heap_;
-        size_t heapSize_;
-        size_t heapTop_;
-    };
-
-    class GC
-    {
-    public:
-        static GC& Current();
-
-        corlib::ObjectRef<> AllocateObject(vm::EEClass* cls);
-        corlib::ObjectRef<corlib::Array> AllocateArray(vm::EEClass* cls, uint64_t length);
-
-    private:
-        GC();
-
-    private:
-        std::vector<GCHeap> heaps_;
-    };
-}
-}

src/natsuclr/include/loader/AssemblyFile.hpp

@@ -1,32 +0,0 @@
-//
-// Natsu CLR Loader
-//
-#pragma once
-#include <cstdint>
-#include <memory>
-#include <exception>
-
-namespace clr
-{
-	namespace loader
-	{
-		class BadImageException : std::exception
-		{
-			using exception::exception;
-		};
-
-		class AssemblyFile
-		{
-		public:
-			AssemblyFile(std::shared_ptr<const uint8_t[]> data, size_t size);
-
-			const uint8_t* GetDataByRVA(uintptr_t rva) const noexcept;
-			uintptr_t GetMetadataRVA() const noexcept { return metadataRVA_; }
-		private:
-			std::shared_ptr<const uint8_t[]> fileData_;
-			const uint8_t* textBase_;
-			uintptr_t textRVA_;
-			uintptr_t metadataRVA_;
-		};
-	}
-}

src/natsuclr/include/loader/AssemblyLoader.hpp

@@ -1,48 +0,0 @@
-//
-// Natsu CLR Loader
-//
-#pragma once
-#include "../md/MDImporter.hpp"
-#include "../vm/EEClass.hpp"
-#include "AssemblyFile.hpp"
-#include <vector>
-
-namespace clr
-{
-namespace loader
-{
-    class FieldSigVisitor;
-
-    class AssemblyLoader
-    {
-        friend class FieldSigVisitor;
-
-    public:
-        AssemblyLoader(std::shared_ptr<AssemblyFile> assemblyFile);
-
-        void Load();
-        metadata::MDImporter& GetMDImporter() noexcept { return mdImporter_; }
-
-        std::vector<vm::EEClass>& GetClasses() noexcept { return eeClasses_; }
-        vm::MethodDesc& GetMethod(metadata::Ridx<metadata::mdt_MethodDef> method);
-        vm::EEClass& GetClass(metadata::Ridx<metadata::mdt_TypeDef> type);
-        vm::FieldDesc& GetField(metadata::Ridx<metadata::mdt_Field> field);
-
-    private:
-        void LoadTypeDef(uint32_t index);
-        void LoadMethodDef(uint32_t index);
-        void LoadField(uint32_t index);
-        void LoadTypeInstanceField(uint32_t index);
-        void LoadTypeStaticField(uint32_t index);
-        void LoadTypeInstanceField(vm::EEClass& eeClass);
-        void LoadGenericParam(uint32_t index);
-
-    private:
-        std::shared_ptr<AssemblyFile> assemblyFile_;
-        metadata::MDImporter mdImporter_;
-        std::vector<vm::EEClass> eeClasses_;
-        std::vector<vm::MethodDesc> methodDescs_;
-        std::vector<vm::FieldDesc> fieldDescs_;
-    };
-}
-}

src/natsuclr/include/loader/Layout.hpp

@@ -1,73 +0,0 @@
-//
-// Natsu CLR Loader
-//
-#pragma once
-#include "../md/MDImporter.hpp"
-#include "../md/Signature.hpp"
-#include "../vm/EEClass.hpp"
-#include "AssemblyFile.hpp"
-#include <vector>
-
-namespace clr
-{
-namespace loader
-{
-    class AssemblyLoader;
-
-    class MethodSigVisitor : public metadata::SignatureVisitor
-    {
-    public:
-        AssemblyLoader* AssemblyLoader;
-        vm::EEClass* Class;
-
-        std::unique_ptr<vm::VarDesc[]> ParamDescs;
-        uint32_t ParamCount = 0;
-
-        vm::VarDesc RetDesc = {};
-
-    protected:
-        virtual void VisitBeginMethod(uint8_t flag) override;
-        virtual void VisitBeginRetType() override;
-        virtual void VisitBeginParam() override;
-        virtual void VisitParamCount(uint32_t count) override;
-        virtual void VisitBeginType(metadata::CorElementType elementType) override;
-        virtual void VisitTypeDefOrRefEncoded(metadata::CodedRidx<metadata::crid_TypeDefOrRef> cridx) override;
-        virtual void VisitTypeGenericParamNumber(uint32_t number) override;
-
-    private:
-        vm::VarDesc* cntVar_;
-        uint8_t flag_;
-        size_t cntParam_ = -1;
-    };
-
-    class LocalVarSigVisitor : public metadata::SignatureVisitor
-    {
-    public:
-        AssemblyLoader* AssemblyLoader;
-
-        std::unique_ptr<vm::VarDesc[]> LocalVarDescs;
-        uint32_t LocalVarCount;
-
-        virtual void VisitLocalVarCount(uint32_t count) override;
-        virtual void VisitBeginLocalVar() override;
-        virtual void VisitBeginType(metadata::CorElementType elementType) override;
-        virtual void VisitTypeDefOrRefEncoded(metadata::CodedRidx<metadata::crid_TypeDefOrRef> cridx) override;
-
-    private:
-        vm::VarDesc* cntVar_ = nullptr;
-    };
-
-    class FieldSigVisitor : public metadata::SignatureVisitor
-    {
-    public:
-        AssemblyLoader* AssemblyLoader;
-
-        vm::VarDesc FieldVarDesc = {};
-
-        virtual void VisitBeginType(metadata::CorElementType elementType) override;
-        virtual void VisitTypeDefOrRefEncoded(metadata::CodedRidx<metadata::crid_TypeDefOrRef> cridx) override;
-    };
-
-    size_t LayoutVars(AssemblyLoader* assemblyLoader, vm::VarDesc* descs, size_t count);
-}
-}

src/natsuclr/include/md/MDImporter.hpp

@@ -1,427 +0,0 @@
-//
-// Natsu CLR Metadata
-//
-#pragma once
-#include "../loader/AssemblyFile.hpp"
-#include "mddefs.hpp"
-#include <optional>
-#include <string_view>
-
-namespace clr
-{
-namespace metadata
-{
-    class MetadataStream;
-
-    class MetadataTable
-    {
-    public:
-        MetadataTable(size_t count);
-
-        void Initialize(uintptr_t& content, MetadataStream& context);
-        size_t GetCount() const noexcept { return count_; }
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept = 0;
-        uintptr_t GetRowBase(size_t index) const noexcept;
-
-    private:
-        uintptr_t base_;
-        size_t count_;
-        size_t rowSize_;
-    };
-
-    class AssemblyTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            AssemblyHashAlgorithm HashAlgId;
-            uint16_t MajorVersion;
-            uint16_t MinorVersion;
-            uint16_t BuildNumber;
-            uint16_t RevisionNumber;
-            AssemblyFlags Flags;
-            Sidx<stm_Blob> PublicKey;
-            Sidx<stm_String> Name;
-            Sidx<stm_String> Culture;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_Assembly> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class ClassLayoutTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            uint16_t PackingSize;
-            uint32_t ClassSize;
-            Ridx<mdt_TypeDef> Parent;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_ClassLayout> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class ConstantTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            CorElementType Type;
-            uint8_t Reserved0;
-            CodedRidx<crid_HasConstant> Parent;
-            Sidx<stm_Blob> Value;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_Constant> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class CustomAttributeTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            CodedRidx<crid_HasCustomAttribute> Parent;
-            CodedRidx<crid_CustomAttributeType> Type;
-            Sidx<stm_Blob> Value;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_CustomAttribute> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class FieldTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            FieldAttributes Flags;
-            Sidx<stm_String> Name;
-            Sidx<stm_Blob> Signature;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_Field> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class GenericParamTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            uint16_t Number;
-            GenericParamAttributes Flags;
-            CodedRidx<crid_TypeOrMethodDef> Owner;
-            Sidx<stm_String> Name;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_GenericParam> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class MemberRefTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            CodedRidx<crid_MemberRefParent> Class;
-            Sidx<stm_String> Name;
-            Sidx<stm_Blob> Signature;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_MemberRef> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class MethodDefTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            uint32_t RVA;
-            MethodImplAttributes ImplFlags;
-            MethodAttributes Flags;
-            Sidx<stm_String> Name;
-            Sidx<stm_Blob> Signature;
-            Ridx<mdt_Param> ParamList;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_MethodDef> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class MethodSemanticsTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            MethodSemanticsAttributes Semantics;
-            Ridx<mdt_MethodDef> Method;
-            CodedRidx<crid_HasSemantics> Association;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_MethodSemantics> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class ModuleTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            uint16_t Generation;
-            Sidx<stm_String> Name;
-            Sidx<stm_GUID> Mvid;
-            Sidx<stm_GUID> EncId;
-            Sidx<stm_GUID> EncBaseId;
-        };
-
-        using MetadataTable::MetadataTable;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class ParamTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            ParamAttributes Flags;
-            uint16_t Sequence;
-            Sidx<stm_String> Name;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_Param> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class PropertyTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            PropertyAttributes Flags;
-            Sidx<stm_String> Name;
-            Sidx<stm_Blob> Type;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_Property> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class PropertyMapTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            Ridx<mdt_TypeDef> Parent;
-            Ridx<mdt_Property> PropertyList;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_PropertyMap> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class StandAloneSigTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            Sidx<stm_Blob> Signature;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_StandAloneSig> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class TypeDefTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            TypeAttributes Flags;
-            Sidx<stm_String> TypeName;
-            Sidx<stm_String> TypeNamespace;
-            CodedRidx<crid_TypeDefOrRef> Extends;
-            Ridx<mdt_Field> FieldList;
-            Ridx<mdt_MethodDef> MethodList;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_TypeDef> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class TypeSpecTable final : public MetadataTable
-    {
-    public:
-        struct Row
-        {
-            Sidx<stm_Blob> Signature;
-        };
-
-        using MetadataTable::MetadataTable;
-
-        Row GetRow(Ridx<mdt_TypeSpec> ridx, const MetadataStream& context) const;
-
-    protected:
-        virtual size_t GetRowSize(MetadataStream& context) const noexcept override;
-    };
-
-    class MetadataStream
-    {
-    public:
-        void Initialize(uintptr_t content);
-
-        size_t GetRowsCount(MetadataTables table) const noexcept;
-        size_t GetSidxSize(StreamType stream) const noexcept;
-        size_t GetRidxSize(MetadataTables table) const noexcept;
-        size_t GetCodedRidxSize(CodedRowIndex ridxType) const noexcept;
-
-#define DECL_METASTREAM_GET_ROW(type) typename type##Table::Row Get##type(Ridx<mdt_##type> ridx) const
-
-        DECL_METASTREAM_GET_ROW(TypeDef);
-        DECL_METASTREAM_GET_ROW(MethodDef);
-        DECL_METASTREAM_GET_ROW(Field);
-        DECL_METASTREAM_GET_ROW(Param);
-        DECL_METASTREAM_GET_ROW(MemberRef);
-        DECL_METASTREAM_GET_ROW(Constant);
-        DECL_METASTREAM_GET_ROW(CustomAttribute);
-        DECL_METASTREAM_GET_ROW(ClassLayout);
-        DECL_METASTREAM_GET_ROW(StandAloneSig);
-        DECL_METASTREAM_GET_ROW(PropertyMap);
-        DECL_METASTREAM_GET_ROW(Property);
-        DECL_METASTREAM_GET_ROW(MethodSemantics);
-        DECL_METASTREAM_GET_ROW(TypeSpec);
-        DECL_METASTREAM_GET_ROW(Assembly);
-        DECL_METASTREAM_GET_ROW(GenericParam);
-
-    private:
-        std::unique_ptr<MetadataTable> tables_[mdt_Count];
-        uint8_t heapSizes_;
-    };
-
-    class StringsStream
-    {
-    public:
-        void Initialize(uintptr_t content);
-
-        std::string_view GetString(Sidx<stm_String> sidx) const noexcept;
-
-    private:
-        const char* content_;
-    };
-
-    class USStream
-    {
-    public:
-        void Initialize(uintptr_t content);
-
-        const char* GetString(Sidx<stm_String> sidx) const noexcept;
-
-    private:
-        const char* content_;
-    };
-
-    class GUIDStream
-    {
-    public:
-        void Initialize(uintptr_t content);
-
-        const char* GetString(Sidx<stm_String> sidx) const noexcept;
-
-    private:
-        const char* content_;
-    };
-
-    class BlobStream
-    {
-    public:
-        void Initialize(uintptr_t content);
-
-        BlobData GetBlob(Sidx<stm_Blob> sidx) const;
-
-    private:
-        const uint8_t* content_;
-    };
-
-    class MDImporter
-    {
-    public:
-        MDImporter(std::shared_ptr<loader::AssemblyFile> assemblyFile);
-
-        const MetadataStream& GetTables() const noexcept { return metaStream_; }
-        const StringsStream& GetStrings() const noexcept { return stringsStream_; }
-        const BlobStream& GetBlobs() const noexcept { return blobStream_; }
-
-    private:
-        std::shared_ptr<loader::AssemblyFile> assemblyFile_;
-
-        MetadataStream metaStream_;
-        StringsStream stringsStream_;
-        USStream usStream_;
-        GUIDStream guidStream_;
-        BlobStream blobStream_;
-    };
-}
-}

src/natsuclr/include/md/Signature.hpp

@@ -1,105 +0,0 @@
-//
-// Natsu CLR Metadata
-//
-#pragma once
-#include "mddefs.hpp"
-
-namespace clr
-{
-namespace metadata
-{
-#define SIG_METHOD_DEFAULT 0x0 // default calling convention
-#define SIG_METHOD_C 0x1 // C calling convention
-#define SIG_METHOD_STDCALL 0x2 // Stdcall calling convention
-#define SIG_METHOD_THISCALL 0x3 // thiscall  calling convention
-#define SIG_METHOD_FASTCALL 0x4 // fastcall calling convention
-#define SIG_METHOD_VARARG 0x5 // vararg calling convention
-#define SIG_FIELD 0x6 // encodes a field
-#define SIG_LOCAL_SIG 0x7 // used for the .locals directive
-#define SIG_PROPERTY 0x8 // used to encode a property
-
-#define SIG_GENERIC 0x10 // used to indicate that the method has one or more generic parameters.
-#define SIG_HASTHIS 0x20 // used to encode the keyword instance in the calling convention
-#define SIG_EXPLICITTHIS 0x40 // used to encode the keyword explicit in the calling convention
-
-#define SIG_INDEX_TYPE_TYPEDEF 0 // ParseTypeDefOrRefEncoded returns this as the out index type for typedefs
-#define SIG_INDEX_TYPE_TYPEREF 1 // ParseTypeDefOrRefEncoded returns this as the out index type for typerefs
-#define SIG_INDEX_TYPE_TYPESPEC 2 // ParseTypeDefOrRefEncoded returns this as the out index type for typespecs
-
-    class SigParser;
-    class Signature
-    {
-    public:
-        Signature() {}
-        Signature(BlobData blobData)
-            : blobData_(blobData) {}
-
-        bool IsEmpty() const noexcept { return blobData_.Length == 0; }
-        SigParser CreateParser() const noexcept;
-
-    private:
-        BlobData blobData_;
-    };
-
-    class SigParser
-    {
-    public:
-        SigParser(const uint8_t* base, size_t len)
-            : base_(base), len_(len) {}
-
-        uint8_t GetByte();
-        uint8_t PeekByte();
-        uint32_t GetNumber();
-        bool IsEmpty() const noexcept;
-
-    private:
-        void SkipBytes(size_t len);
-
-    private:
-        const uint8_t* base_;
-        size_t len_;
-    };
-
-    class SignatureVisitor
-    {
-    public:
-        void Parse(SigParser& parser);
-
-    protected:
-        virtual void VisitBeginField(uint8_t flag);
-        virtual void VisitEndField();
-        virtual void VisitTypeDefOrRefEncoded(CodedRidx<crid_TypeDefOrRef> cridx);
-        virtual void VisitBeginType(CorElementType elementType);
-        virtual void VisitEndType();
-        virtual void VisitBeginMethod(uint8_t flag);
-        virtual void VisitEndMethod();
-        virtual void VisitParamCount(uint32_t number);
-        virtual void VisitBeginRetType();
-        virtual void VisitEndRetType();
-        virtual void VisitBeginParam();
-        virtual void VisitEndParam();
-        virtual void VisitBeginLocalVars(uint8_t flag);
-        virtual void VisitEndLocalVars();
-        virtual void VisitLocalVarCount(uint32_t number);
-        virtual void VisitBeginLocalVar();
-        virtual void VisitEndLocalVar();
-        virtual void VisitTypeGenericParamNumber(uint32_t number);
-        virtual void VisitBeginSzArray();
-        virtual void VisitEndSzArray();
-
-    private:
-        void ParseMethod(SigParser& parser, uint8_t flag);
-        void ParseField(SigParser& parser, uint8_t flag);
-        void ParseLocals(SigParser& parser, uint8_t flag);
-        void ParseProperty(SigParser& parser, uint8_t flag);
-
-        void ParseOptionalCustomMods(SigParser& parser);
-        void ParseType(SigParser& parser);
-        void ParseCustomMod(SigParser& parser);
-        void ParseTypeDefOrRefEncoded(SigParser& parser);
-        void ParseRetType(SigParser& parser);
-        void ParseParam(SigParser& parser);
-        void ParseLocalVar(SigParser& parser);
-    };
-}
-}

src/natsuclr/include/md/mddefs.hpp

@@ -1,392 +0,0 @@
-//
-// Natsu CLR Metadata
-//
-#pragma once
-#include "../utils.hpp"
-#include <cstdint>
-#include <exception>
-
-namespace clr
-{
-namespace metadata
-{
-    class BadMetadataException : std::exception
-    {
-        using exception::exception;
-    };
-
-    class NotSupportedException : std::exception
-    {
-        using exception::exception;
-    };
-
-    enum class AssemblyHashAlgorithm : uint32_t
-    {
-    };
-
-    enum class AssemblyFlags : uint32_t
-    {
-
-    };
-
-    enum class EventFlags : uint32_t
-    {
-    };
-
-    enum class FieldAttributes : uint16_t
-    {
-        CompilerControlled = 0x0,
-        Private = 0x1,
-        FamANDAssem = 0x2,
-        Assembly = 0x3,
-        Family = 0x4,
-        FamORAssem = 0x5,
-        Public = 0x6,
-        Static = 0x10,
-        InitOnly = 0x20,
-        Literal = 0x40,
-        NotSerialized = 0x80,
-        SpecialName = 0x200,
-        PInvokeImpl = 0x2000,
-        RTSpecialName = 0x400,
-        HasFieldMarshal = 0x1000,
-        HasDefault = 0x8000,
-        HasFieldRVA = 0x100
-    };
-
-#define FieldAttributes_FieldAccessMask 0x7
-
-    enum class FileAttributes : uint32_t
-    {
-    };
-
-    enum class GenericParamAttributes : uint16_t
-    {
-        None = 0x0000,
-        Covariant = 0x0001,
-        Contravariant = 0x0002,
-        ReferenceTypeConstraint = 0x004,
-        NotNullableValueTypeConstraint = 0x0008,
-        DefaultConstructorConstraint = 0x0010
-    };
-
-#define GenericParamAttributes_VarianceMask 0x0003
-#define GenericParamAttributes_SpecialConstraintMask 0x001C
-
-    enum class MethodImplAttributes : uint16_t
-    {
-        IL = 0x0,
-        Native = 0x1,
-        OPTIL = 0x2,
-        Runtime = 0x3,
-
-        Unmanaged = 0x4,
-        Managed = 0x0,
-
-        InternalCall = 0x1000
-    };
-
-    enum class MethodAttributes : uint16_t
-    {
-        CompilerControlled = 0x0000,
-        Private = 0x0001,
-        FamANDAssem = 0x0002,
-        Assem = 0x0003,
-        Family = 0x0004,
-        FamORAssem = 0x0005,
-        Public = 0x0006,
-        Static = 0x0010,
-        Final = 0x0020,
-        Virtual = 0x0040,
-        HideBySig = 0x0080,
-        ReuseSlot = 0x0000,
-        NewSlot = 0x0100,
-        Strict = 0x0200,
-        Abstract = 0x0400,
-        SpecialName = 0x0800,
-        PInvokeImpl = 0x2000,
-        UnmanagedExport = 0x0008,
-        RTSpecialName = 0x1000,
-        HasSecurity = 0x4000,
-        RequireSecObject = 0x8000
-    };
-
-#define MethodAttributes_MemberAccessMask 0x0007
-#define MethodAttributes_VtableLayoutMask 0x0010
-
-    enum class TypeAttributes : uint32_t
-    {
-        // Visibility attributes
-        NotPublic = 0x0,
-        Public = 0x1,
-        NestedPublic = 0x2,
-        NestedPrivate = 0x3,
-        NestedFamily = 0x4,
-        NestedAssembly = 0x5,
-        NestedFamANDAssem = 0x6,
-        NestedFamORAssem = 0x7
-    };
-
-#define TypeAttributes_VisibilityMask 0x7
-
-    enum class ParamAttributes : uint16_t
-    {
-
-    };
-
-    enum class PropertyAttributes : uint16_t
-    {
-
-    };
-
-    enum class MethodSemanticsAttributes : uint16_t
-    {
-
-    };
-
-#ifdef MAKE_ENUM_CLASS_BITMASK_TYPE
-    MAKE_ENUM_CLASS_BITMASK_TYPE(MethodImplAttributes);
-    MAKE_ENUM_CLASS_BITMASK_TYPE(FieldAttributes);
-    MAKE_ENUM_CLASS_BITMASK_TYPE(MethodAttributes);
-#endif
-
-    enum StreamType
-    {
-        stm_String = 1,
-        stm_GUID = 2,
-        stm_Blob = 4
-    };
-
-    enum MetadataTables
-    {
-        mdt_Assembly = 0x20,
-        mdt_AssemblyOS = 0x22,
-        mdt_AssemblyProcessor = 0x21,
-        mdt_AssemblyRef = 0x23,
-        mdt_AssemblyRefOS = 0x25,
-        mdt_AssemblyRefProcessor = 0x24,
-        mdt_ClassLayout = 0x0F,
-        mdt_Constant = 0x0B,
-        mdt_CustomAttribute = 0x0C,
-        mdt_DeclSecurity = 0x0E,
-        mdt_EventMap = 0x12,
-        mdt_Event = 0x14,
-        mdt_ExportedType = 0x27,
-        mdt_Field = 0x04,
-        mdt_FieldLayout = 0x10,
-        mdt_FieldMarshal = 0x0D,
-        mdt_FieldRVA = 0x1D,
-        mdt_File = 0x26,
-        mdt_GenericParam = 0x2A,
-        mdt_GenericParamConstraint = 0x2C,
-        mdt_ImplMap = 0x1C,
-        mdt_InterfaceImp = 0x09,
-        mdt_ManifestResource = 0x28,
-        mdt_MemberRef = 0x0A,
-        mdt_MethodDef = 0x06,
-        mdt_MethodImpl = 0x19,
-        mdt_MethodSemantics = 0x18,
-        mdt_MethodSpec = 0x2B,
-        mdt_Module = 0x00,
-        mdt_ModuleRef = 0x1A,
-        mdt_NestedClass = 0x29,
-        mdt_Param = 0x08,
-        mdt_Property = 0x17,
-        mdt_PropertyMap = 0x15,
-        mdt_StandAloneSig = 0x11,
-        mdt_TypeDef = 0x02,
-        mdt_TypeRef = 0x01,
-        mdt_TypeSpec = 0x1B,
-        mdt_Count = 0x2d
-    };
-
-    enum CodedRowIndex
-    {
-        crid_TypeDefOrRef,
-        crid_HasConstant,
-        crid_HasCustomAttribute,
-        crid_HasFieldMarshall,
-        crid_HasDeclSecurity,
-        crid_MemberRefParent,
-        crid_HasSemantics,
-        crid_MethodDefOrRef,
-        crid_MemberForwarded,
-        crid_Implementation,
-        crid_CustomAttributeType,
-        crid_ResolutionScope,
-        crid_TypeOrMethodDef
-    };
-
-    template <MetadataTables Table>
-    struct Ridx
-    {
-        uint32_t Index;
-
-        uint32_t operator()() const noexcept { return Index; }
-        uint32_t& operator()() noexcept { return Index; }
-        operator bool() const noexcept { return Index != 0; }
-
-        Ridx& operator++() noexcept
-        {
-            Index++;
-            return *this;
-        }
-
-        bool operator==(const Ridx& other) const noexcept
-        {
-            return Index == other;
-        }
-
-        bool operator!=(const Ridx& other) const noexcept
-        {
-            return Index != other;
-        }
-    };
-
-    template <StreamType Stream>
-    struct Sidx
-    {
-        uint32_t Index;
-
-        uint32_t operator()() const noexcept { return Index; }
-        uint32_t& operator()() noexcept { return Index; }
-    };
-
-    template <CodedRowIndex Type>
-    struct CodedRidx
-    {
-    };
-
-    namespace impl
-    {
-        template <class T, T... Values>
-        struct value_sequence
-        {
-            constexpr size_t size() const noexcept { return sizeof...(Values); }
-        };
-
-        template <size_t TagBits, MetadataTables... Types>
-        struct CodedRidxImpl
-        {
-            using PackedTypes = value_sequence<MetadataTables, Types...>;
-
-            static_assert(TagBits != 0, "Invalid tag bits.");
-            static constexpr size_t SizeThreshold = 1 << (16 - TagBits);
-
-            uint32_t CodedValue;
-
-            template <MetadataTables Table>
-            Ridx<Table> As() const { return { CodedValue >> TagBits }; }
-            operator bool() const noexcept { return (CodedValue >> TagBits) != 0; }
-
-            MetadataTables GetType() const
-            {
-                auto tag = GetTag();
-                if (tag >= sizeof...(Types))
-                    THROW_ALWAYS(BadMetadataException);
-                return TypeValues[tag];
-            }
-
-        protected:
-            static constexpr size_t TagMask = (1 << TagBits) - 1;
-            static constexpr MetadataTables TypeValues[] = { Types... };
-
-            size_t GetTag() const noexcept { return CodedValue & TagMask; }
-        };
-    }
-
-    template <>
-    struct CodedRidx<crid_TypeDefOrRef> : public impl::CodedRidxImpl<2, mdt_TypeDef, mdt_TypeRef, mdt_TypeSpec>
-    {
-    };
-
-    template <>
-    struct CodedRidx<crid_HasConstant> : public impl::CodedRidxImpl<2, mdt_Field, mdt_Param, mdt_Property>
-    {
-    };
-
-    template <>
-    struct CodedRidx<crid_HasCustomAttribute> : public impl::CodedRidxImpl<5, mdt_MethodDef, mdt_Field, mdt_TypeRef, mdt_TypeDef, mdt_Param, mdt_InterfaceImp, mdt_MemberRef, mdt_Module, mdt_Property, mdt_Event, mdt_StandAloneSig, mdt_ModuleRef, mdt_TypeSpec, mdt_Assembly, mdt_AssemblyRef, mdt_File, mdt_ExportedType, mdt_ManifestResource, mdt_GenericParam, mdt_GenericParamConstraint, mdt_MethodSpec>
-    {
-    };
-
-    template <>
-    struct CodedRidx<crid_CustomAttributeType> : public impl::CodedRidxImpl<3, mdt_MethodDef, mdt_MemberRef>
-    {
-    };
-
-    template <>
-    struct CodedRidx<crid_HasSemantics> : public impl::CodedRidxImpl<1, mdt_Event, mdt_Property>
-    {
-    };
-
-    template <>
-    struct CodedRidx<crid_TypeOrMethodDef> : public impl::CodedRidxImpl<1, mdt_TypeDef, mdt_MethodDef>
-    {
-    };
-
-    template <>
-    struct CodedRidx<crid_MemberRefParent> : public impl::CodedRidxImpl<3, mdt_TypeDef, mdt_TypeRef, mdt_ModuleRef, mdt_MethodDef, mdt_TypeSpec>
-    {
-    };
-
-    struct BlobData
-    {
-        const uint8_t* Data;
-        size_t Length;
-    };
-
-    enum CorElementType : uint8_t
-    {
-        ELEMENT_TYPE_END = 0x00,
-        ELEMENT_TYPE_VOID = 0x01,
-        ELEMENT_TYPE_BOOLEAN = 0x02,
-        ELEMENT_TYPE_CHAR = 0x03,
-        ELEMENT_TYPE_I1 = 0x04,
-        ELEMENT_TYPE_U1 = 0x05,
-        ELEMENT_TYPE_I2 = 0x06,
-        ELEMENT_TYPE_U2 = 0x07,
-        ELEMENT_TYPE_I4 = 0x08,
-        ELEMENT_TYPE_U4 = 0x09,
-        ELEMENT_TYPE_I8 = 0x0a,
-        ELEMENT_TYPE_U8 = 0x0b,
-        ELEMENT_TYPE_R4 = 0x0c,
-        ELEMENT_TYPE_R8 = 0x0d,
-        ELEMENT_TYPE_STRING = 0x0e,
-
-        // every type above PTR will be simple type
-        ELEMENT_TYPE_PTR = 0x0f, // PTR <type>
-        ELEMENT_TYPE_BYREF = 0x10, // BYREF <type>
-
-        // Please use ELEMENT_TYPE_VALUETYPE. ELEMENT_TYPE_VALUECLASS is deprecated.
-        ELEMENT_TYPE_VALUETYPE = 0x11, // VALUETYPE <class Token>
-        ELEMENT_TYPE_CLASS = 0x12, // CLASS <class Token>
-        ELEMENT_TYPE_VAR = 0x13, // a class type variable VAR <number>
-        ELEMENT_TYPE_ARRAY = 0x14, // MDARRAY <type> <rank> <bcount> <bound1> ... <lbcount> <lb1> ...
-        ELEMENT_TYPE_GENERICINST = 0x15, // GENERICINST <generic type> <argCnt> <arg1> ... <argn>
-        ELEMENT_TYPE_TYPEDBYREF = 0x16, // TYPEDREF  (it takes no args) a typed referece to some other type
-
-        ELEMENT_TYPE_I = 0x18, // native integer size
-        ELEMENT_TYPE_U = 0x19, // native unsigned integer size
-        ELEMENT_TYPE_FNPTR = 0x1b, // FNPTR <complete sig for the function including calling convention>
-        ELEMENT_TYPE_OBJECT = 0x1c, // Shortcut for System.Object
-        ELEMENT_TYPE_SZARRAY = 0x1d, // Shortcut for single dimension zero lower bound array
-        // SZARRAY <type>
-        ELEMENT_TYPE_MVAR = 0x1e, // a method type variable MVAR <number>
-
-        // This is only for binding
-        ELEMENT_TYPE_CMOD_REQD = 0x1f, // required C modifier : E_T_CMOD_REQD <mdTypeRef/mdTypeDef>
-        ELEMENT_TYPE_CMOD_OPT = 0x20, // optional C modifier : E_T_CMOD_OPT <mdTypeRef/mdTypeDef>
-
-        // This is for signatures generated internally (which will not be persisted in any way).
-        ELEMENT_TYPE_INTERNAL = 0x21, // INTERNAL <typehandle>
-
-        // Note that this is the max of base type excluding modifiers
-        ELEMENT_TYPE_MAX = 0x22, // first invalid element type
-
-        ELEMENT_TYPE_MODIFIER = 0x40,
-        ELEMENT_TYPE_SENTINEL = 0x01 | ELEMENT_TYPE_MODIFIER, // sentinel for varargs
-        ELEMENT_TYPE_PINNED = 0x05 | ELEMENT_TYPE_MODIFIER
-    };
-}
-}

src/natsuclr/include/utils.hpp

@@ -1,92 +0,0 @@
-#pragma once
-#include <cstdint>
-#include <type_traits>
-
-#define THROW_ALWAYS(exception,...) throw exception(__VA_ARGS__);
-#define THROW_IF_NOT(expr,exception,...) {if(!(expr)) throw exception(__VA_ARGS__);}
-
-#define MAKE_ENUM_CLASS_BITMASK_TYPE(enumName) static_assert(std::is_enum<enumName>::value, "enumName is not a enum.");\
-	constexpr enumName operator|(enumName a, enumName b) noexcept\
-	{\
-		typedef std::underlying_type_t<enumName> underlying_type;\
-		return static_cast<enumName>(static_cast<underlying_type>(a) | static_cast<underlying_type>(b));\
-	}\
-	constexpr enumName operator&(enumName a, enumName b) noexcept\
-	{\
-		typedef std::underlying_type_t<enumName> underlying_type;\
-		return static_cast<enumName>(static_cast<underlying_type>(a) & static_cast<underlying_type>(b));\
-	}\
-	constexpr enumName operator^(enumName a, enumName b) noexcept\
-	{\
-		typedef std::underlying_type_t<enumName> underlying_type;\
-		return static_cast<enumName>(static_cast<underlying_type>(a) ^ static_cast<underlying_type>(b));\
-	}\
-	constexpr enumName operator~(enumName a) noexcept\
-	{\
-		typedef std::underlying_type_t<enumName> underlying_type;\
-		return static_cast<enumName>(~static_cast<underlying_type>(a));\
-	}\
-	constexpr enumName& operator|=(enumName& a, enumName b) noexcept\
-	{\
-		return a = (a | b);\
-	}\
-	constexpr enumName& operator&=(enumName& a, enumName b) noexcept\
-	{\
-		return a = (a & b);\
-	}\
-	constexpr enumName& operator^=(enumName& a, enumName b) noexcept\
-	{\
-		return a = (a ^ b);\
-	}
-
-
-template<class T>
-constexpr T align(T value, size_t base)
-{
-	auto r = value % base;
-	return T(r ? value + (base - r) : value);
-}
-
-struct BinaryReader
-{
-	BinaryReader(uintptr_t base)
-		:base_(base)
-	{
-	}
-
-	template<class T>
-	T Read() noexcept
-	{
-		auto offset = base_;
-		base_ += sizeof(T);
-
-		// aligned read
-		if (offset % sizeof(T) == 0)
-			return *reinterpret_cast<const T*>(offset);
-		else
-		{
-			alignas(alignof(T)) uint8_t value[sizeof(T)];
-			auto begin = reinterpret_cast<const uint8_t*>(offset);
-			for (size_t i = 0; i < sizeof(T); i++)
-				value[i] = begin[i];
-			return *reinterpret_cast<const T*>(value);
-		}
-	}
-
-	template<class T>
-	T Read(size_t size)
-	{
-		if (size == 1)
-			return { Read<uint8_t>() };
-		else if (size == 2)
-			return { Read<uint16_t>() };
-		else if (size == 4)
-			return { Read<uint32_t>() };
-		else
-			throw std::invalid_argument("invalid size");
-	}
-
-	uintptr_t GetOffset() const noexcept { return base_; }
-private:
-	uintptr_t base_;
-};

src/natsuclr/include/vm/ECall.hpp

@@ -1,36 +0,0 @@
-//
-// Natsu CLR VM
-//
-#pragma once
-#include "../md/mddefs.hpp"
-#include "EEClass.hpp"
-
-namespace clr
-{
-namespace vm
-{
-    class ECallNotFoundException : std::exception
-    {
-        using exception::exception;
-    };
-
-    class EvaluationStack;
-
-    struct ECall
-    {
-        std::string_view MethodName;
-
-        uintptr_t EntryPoint;
-        ECallInvoker Call;
-    };
-
-    struct ECallClass
-    {
-        std::string_view Namespace;
-        std::string_view ClassName;
-        const ECall* ECalls;
-    };
-
-    const ECall& FindECall(const MethodDesc& method);
-}
-}

src/natsuclr/include/vm/ECallList.hpp

@@ -1,34 +0,0 @@
-//
-// Natsu CLR VM
-//
-
-#ifndef ECFuncStart
-#define ECFuncStart(funcvar, ns, cls)
-#endif
-
-#ifndef ECFuncEnd
-#define ECFuncEnd()
-#endif
-
-#ifndef ECFuncElement
-#define ECFuncElement(name, func)
-#endif
-
-ECFuncStart(g_ArrayFuncs, "System", "Array")
-	ECFuncElement("get_LongLength", &clr::corlib::Array::get_LongLength)
-	ECFuncElement("get_Rank", &clr::corlib::Array::get_Rank)
-	ECFuncElement("get_Length", &clr::corlib::Array::get_Length)
-	ECFuncElement("GetLength", &clr::corlib::Array::GetLength)
-ECFuncEnd()
-
-ECFuncStart(g_ConsoleFuncs, "System", "Console")
-	ECFuncElement("SayHello", &clr::corlib::Console::SayHello)
-ECFuncEnd()
-
-ECFuncStart(g_ObjectFuncs, "System", "Object")
-	ECFuncElement("GetType", &clr::corlib::Object::GetType)
-ECFuncEnd()
-
-#undef ECFuncStart
-#undef ECFuncEnd
-#undef ECFuncElement

src/natsuclr/include/vm/EEClass.hpp

@@ -1,166 +0,0 @@
-//
-// Natsu CLR VM
-//
-#pragma once
-#include "../md/mddefs.hpp"
-#include <memory>
-#include <string_view>
-#include <vector>
-
-namespace clr
-{
-namespace metadata
-{
-    class MDImporter;
-}
-
-namespace vm
-{
-    enum ClassLoadLevel
-    {
-        clsLoad_NotLoaded,
-        clsLoad_InstanceFields,
-        clsLoad_StaticFields
-    };
-
-    enum TypeDescAttributes
-    {
-        tda_Normal = 0x0,
-        tda_ByRef = 0x1,
-        tda_Generic = 0x2,
-        tda_SzArray = 0x4
-    };
-
-#ifdef MAKE_ENUM_CLASS_BITMASK_TYPE
-    MAKE_ENUM_CLASS_BITMASK_TYPE(TypeDescAttributes);
-#endif
-
-    struct EEClass;
-
-    struct GenericDesc
-    {
-        uint32_t Number;
-        std::string_view Name;
-    };
-
-    struct TypeDesc
-    {
-        TypeDescAttributes Flags;
-        metadata::CorElementType Type;
-        GenericDesc* GenericParam;
-
-        EEClass* Class;
-
-        bool IsEmpty() const noexcept;
-        size_t GetStackSize() const noexcept;
-        size_t GetAlign() const noexcept;
-    };
-
-    struct VarDesc
-    {
-        uint32_t Offset;
-        TypeDesc Type;
-    };
-
-    class EvaluationStack;
-    class CalleeInfo;
-    struct EEClass;
-
-    typedef void (*ECallInvoker)(uintptr_t entryPoint, CalleeInfo& callee);
-
-    struct MethodDesc
-    {
-        EEClass* Class;
-
-        std::string_view Name;
-        bool IsECall;
-
-        std::unique_ptr<VarDesc[]> ParamDescs;
-        std::unique_ptr<VarDesc[]> LocalVarDescs;
-        std::vector<GenericDesc> GenericParams;
-        TypeDesc RetDesc;
-
-        uint32_t ParamCount;
-        uint32_t LocalVarSize;
-        uint32_t LocalVarCount;
-
-        union {
-            struct
-            {
-                uint16_t MaxStack;
-                const uint8_t* BodyBegin;
-                const uint8_t* BodyEnd;
-            };
-
-            struct
-            {
-                uintptr_t EntryPoint;
-                ECallInvoker Call;
-            } ECall;
-        };
-
-        size_t GetParamSize() const;
-        size_t GetLocalVarSize() const;
-        size_t GetRetSize() const;
-
-        size_t GetParamAlign() const;
-        size_t GetLocalVarAlign() const;
-        size_t GetRetAlign() const;
-    };
-
-    struct FieldDesc
-    {
-        EEClass* Class;
-        metadata::Ridx<metadata::mdt_Field> Ridx;
-        metadata::FieldAttributes Flags;
-
-        std::string_view Name;
-
-        VarDesc Var;
-    };
-
-    struct EEClass
-    {
-        metadata::MDImporter* MDImporter;
-
-        std::string_view TypeName;
-        std::string_view TypeNamespace;
-
-        EEClass* Parent;
-
-        MethodDesc* FirstMethod;
-        MethodDesc* LastMethod;
-
-        FieldDesc* FirstField;
-        FieldDesc* LastField;
-
-        uint32_t Align;
-
-        uint32_t InstanceSize;
-
-        std::unique_ptr<uint8_t[]> StaticFields;
-        std::vector<GenericDesc> GenericParams;
-
-        ClassLoadLevel LoadLevel;
-    };
-
-    struct mdToken
-    {
-        mdToken(uint32_t value)
-            : value_(value) {}
-
-        static constexpr uint32_t TypeBitsOffset = 24;
-        static constexpr uint32_t TypeMask = 0xFF << TypeBitsOffset;
-
-        metadata::MetadataTables GetType() const noexcept { return static_cast<metadata::MetadataTables>((value_ & TypeMask) >> TypeBitsOffset); }
-
-        template <metadata::MetadataTables Type>
-        metadata::Ridx<Type> As() const noexcept { return { value_ & ~TypeMask }; }
-
-        operator bool() const noexcept { return value_ != 0; }
-
-    private:
-        uint32_t value_;
-    };
-}
-}

src/natsuclr/include/vm/EvaluationStack.hpp

@@ -1,63 +0,0 @@
-//
-// Natsu CLR VM
-//
-#pragma once
-#include "EEClass.hpp"
-#include <algorithm>
-#include <stack>
-#include <type_traits>
-#include <vector>
-
-namespace clr
-{
-namespace vm
-{
-    class StackOverflowException : std::exception
-    {
-        using exception::exception;
-    };
-
-    class EvaluationStack
-    {
-        struct FrameMarker
-        {
-            const MethodDesc& Method;
-            size_t VarsOffset;
-        };
-    public:
-        EvaluationStack(size_t stackSize = 4096);
-
-        void PushVar(const void* value, const TypeDesc& type);
-        uint8_t* GetTopVar(TypeDesc& type);
-        void PopVar();
-        uint8_t* PopTopVar(TypeDesc& type);
-
-        void PushFrame(const MethodDesc& method);
-        void PopFrame();
-
-    private:
-        std::unique_ptr<uint8_t[]> stack_;
-        size_t stackPointer_;
-        size_t stackSize_;
-        std::vector<VarDesc> stackVars_;
-        std::stack<FrameMarker> frames_;
-    };
-
-    class CalleeInfo
-    {
-    public:
-        CalleeInfo(const MethodDesc& method);
-
-        uint8_t* GetArg(size_t index, TypeDesc& type);
-        uint8_t* GetLocalVar(size_t index, TypeDesc& type);
-        uint8_t* GetRet(TypeDesc& type);
-
-    private:
-        const MethodDesc& method_;
-        std::unique_ptr<uint8_t[]> data_;
-        size_t argPointer_;
-        size_t localVarPointer_;
-        size_t retPointer_;
-    };
-}
-}

src/natsuclr/include/vm/Interpreter.hpp

@@ -1,48 +0,0 @@
-//
-// Natsu CLR VM
-//
-#pragma once
-#include "../loader/AssemblyLoader.hpp"
-#include "../md/mddefs.hpp"
-#include "EvaluationStack.hpp"
-#include "opinfo.h"
-
-namespace clr
-{
-namespace vm
-{
-    class ExecutionException : std::exception
-    {
-        using exception::exception;
-    };
-
-    class Interpreter
-    {
-    public:
-        Interpreter(loader::AssemblyLoader& assemblyLoader);
-
-        void ExecuteMethod(const MethodDesc& method);
-
-    private:
-        void ExecuteOp(OpInfo& op, OpArgsVal& args);
-        void ExecuteILMethod(const MethodDesc& method);
-
-        template <opcode_t OpCode>
-        void ExecuteOp(OpInfo& op, OpArgsVal& args);
-
-    private:
-        void ExecuteOp_LDARG(size_t index);
-        void ExecuteOp_LDLOC(size_t index);
-        void ExecuteOp_STLOC(size_t index);
-        void ExecuteOp_LDC_I4(int32_t i);
-        void ExecuteOp_STELEM(clr::metadata::CorElementType type);
-        uint64_t PopIndexOrArrayLength();
-    private:
-        EvaluationStack evalStack_;
-        loader::AssemblyLoader& assemblyLoader_;
-
-        std::stack<const uint8_t*> IP_;
-        std::stack<CalleeInfo> calleeInfo_;
-    };
-}
-}

src/natsuclr/include/vm/MethodTable.hpp

@@ -1,16 +0,0 @@
-//
-// Natsu CLR VM
-//
-#pragma once
-#include "EEClass.hpp"
-
-namespace clr
-{
-	namespace vm
-	{
-		struct MethodTable
-		{
-			EEClass* Class;
-		};
-	}
-}

src/natsuclr/include/vm/Thread.hpp

@@ -1,20 +0,0 @@
-//
-// Natsu CLR VM
-//
-#pragma once
-#include "EEClass.hpp"
-#include "loader/AssemblyLoader.hpp"
-
-namespace clr
-{
-	namespace vm
-	{
-		class Thread
-		{
-		public:
-			loader::AssemblyLoader* assemblyLoader_;
-
-			void Execute(const MethodDesc& method);
-		};
-	}
-}

src/natsuclr/include/vm/opcode.def

@@ -1,359 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-/*****************************************************************************
- **                                                                         **
- ** Opcode.def - COM+ Intrinsic Opcodes and Macros.                         **
- **                                                                         **
- ** This is the master table from which all opcode lists                    **
- ** are derived.  New instructions must be added to this                    **
- ** table and generators run to produce the lookup tables                   **
- ** used by the interpreter loop.                                           **
- **                                                                         **
- ** Stack Behaviour is describing the number of 4 byte                      **
- ** slots pushed and Poped.                                                 **
- **                                                                         **
- *****************************************************************************/
-
-
-#ifndef __OPCODE_DEF_
-#define __OPCODE_DEF_
-
-#define MOOT    0x00    // Marks unused second byte when encoding single
-#define STP1    0xFE    // Prefix code 1 for Standard Map
-#define REFPRE  0xFF    // Prefix for Reference Code Encoding
-#define RESERVED_PREFIX_START 0xF7
-
-#endif
-
-// If the first byte of the standard encoding is 0xFF, then
-// the second byte can be used as 1 byte encoding.  Otherwise                                                               l   b         b
-// the encoding is two bytes.                                                                                               e   y         y
-//                                                                                                                          n   t         t
-//                                                                                                                          g   e         e
-//                                                                                                           (unused)       t
-//  Canonical Name                    String Name              Stack Behaviour           Operand Params    Opcode Kind      h   1         2    Control Flow
-// -------------------------------------------------------------------------------------------------------------------------------------------------------
-OPDEF(CEE_NOP,                        "nop",              Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x00,    NEXT)
-OPDEF(CEE_BREAK,                      "break",            Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x01,    BREAK)
-OPDEF(CEE_LDARG_0,                    "ldarg.0",          Pop0,               Push1,       InlineNone,         IMacro,      1,  0xFF,    0x02,    NEXT)
-OPDEF(CEE_LDARG_1,                    "ldarg.1",          Pop0,               Push1,       InlineNone,         IMacro,      1,  0xFF,    0x03,    NEXT)
-OPDEF(CEE_LDARG_2,                    "ldarg.2",          Pop0,               Push1,       InlineNone,         IMacro,      1,  0xFF,    0x04,    NEXT)
-OPDEF(CEE_LDARG_3,                    "ldarg.3",          Pop0,               Push1,       InlineNone,         IMacro,      1,  0xFF,    0x05,    NEXT)
-OPDEF(CEE_LDLOC_0,                    "ldloc.0",          Pop0,               Push1,       InlineNone,         IMacro,      1,  0xFF,    0x06,    NEXT)
-OPDEF(CEE_LDLOC_1,                    "ldloc.1",          Pop0,               Push1,       InlineNone,         IMacro,      1,  0xFF,    0x07,    NEXT)
-OPDEF(CEE_LDLOC_2,                    "ldloc.2",          Pop0,               Push1,       InlineNone,         IMacro,      1,  0xFF,    0x08,    NEXT)
-OPDEF(CEE_LDLOC_3,                    "ldloc.3",          Pop0,               Push1,       InlineNone,         IMacro,      1,  0xFF,    0x09,    NEXT)
-OPDEF(CEE_STLOC_0,                    "stloc.0",          Pop1,               Push0,       InlineNone,         IMacro,      1,  0xFF,    0x0A,    NEXT)
-OPDEF(CEE_STLOC_1,                    "stloc.1",          Pop1,               Push0,       InlineNone,         IMacro,      1,  0xFF,    0x0B,    NEXT)
-OPDEF(CEE_STLOC_2,                    "stloc.2",          Pop1,               Push0,       InlineNone,         IMacro,      1,  0xFF,    0x0C,    NEXT)
-OPDEF(CEE_STLOC_3,                    "stloc.3",          Pop1,               Push0,       InlineNone,         IMacro,      1,  0xFF,    0x0D,    NEXT)
-OPDEF(CEE_LDARG_S,                    "ldarg.s",          Pop0,               Push1,       ShortInlineVar,     IMacro,      1,  0xFF,    0x0E,    NEXT)
-OPDEF(CEE_LDARGA_S,                   "ldarga.s",         Pop0,               PushI,       ShortInlineVar,     IMacro,      1,  0xFF,    0x0F,    NEXT)
-OPDEF(CEE_STARG_S,                    "starg.s",          Pop1,               Push0,       ShortInlineVar,     IMacro,      1,  0xFF,    0x10,    NEXT)
-OPDEF(CEE_LDLOC_S,                    "ldloc.s",          Pop0,               Push1,       ShortInlineVar,     IMacro,      1,  0xFF,    0x11,    NEXT)
-OPDEF(CEE_LDLOCA_S,                   "ldloca.s",         Pop0,               PushI,       ShortInlineVar,     IMacro,      1,  0xFF,    0x12,    NEXT)
-OPDEF(CEE_STLOC_S,                    "stloc.s",          Pop1,               Push0,       ShortInlineVar,     IMacro,      1,  0xFF,    0x13,    NEXT)
-OPDEF(CEE_LDNULL,                     "ldnull",           Pop0,               PushRef,     InlineNone,         IPrimitive,  1,  0xFF,    0x14,    NEXT)
-OPDEF(CEE_LDC_I4_M1,                  "ldc.i4.m1",        Pop0,               PushI,       InlineNone,         IMacro,      1,  0xFF,    0x15,    NEXT)
-OPDEF(CEE_LDC_I4_0,                   "ldc.i4.0",         Pop0,               PushI,       InlineNone,         IMacro,      1,  0xFF,    0x16,    NEXT)
-OPDEF(CEE_LDC_I4_1,                   "ldc.i4.1",         Pop0,               PushI,       InlineNone,         IMacro,      1,  0xFF,    0x17,    NEXT)
-OPDEF(CEE_LDC_I4_2,                   "ldc.i4.2",         Pop0,               PushI,       InlineNone,         IMacro,      1,  0xFF,    0x18,    NEXT)
-OPDEF(CEE_LDC_I4_3,                   "ldc.i4.3",         Pop0,               PushI,       InlineNone,         IMacro,      1,  0xFF,    0x19,    NEXT)
-OPDEF(CEE_LDC_I4_4,                   "ldc.i4.4",         Pop0,               PushI,       InlineNone,         IMacro,      1,  0xFF,    0x1A,    NEXT)
-OPDEF(CEE_LDC_I4_5,                   "ldc.i4.5",         Pop0,               PushI,       InlineNone,         IMacro,      1,  0xFF,    0x1B,    NEXT)
-OPDEF(CEE_LDC_I4_6,                   "ldc.i4.6",         Pop0,               PushI,       InlineNone,         IMacro,      1,  0xFF,    0x1C,    NEXT)
-OPDEF(CEE_LDC_I4_7,                   "ldc.i4.7",         Pop0,               PushI,       InlineNone,         IMacro,      1,  0xFF,    0x1D,    NEXT)
-OPDEF(CEE_LDC_I4_8,                   "ldc.i4.8",         Pop0,               PushI,       InlineNone,         IMacro,      1,  0xFF,    0x1E,    NEXT)
-OPDEF(CEE_LDC_I4_S,                   "ldc.i4.s",         Pop0,               PushI,       ShortInlineI,       IMacro,      1,  0xFF,    0x1F,    NEXT)
-OPDEF(CEE_LDC_I4,                     "ldc.i4",           Pop0,               PushI,       InlineI,            IPrimitive,  1,  0xFF,    0x20,    NEXT)
-OPDEF(CEE_LDC_I8,                     "ldc.i8",           Pop0,               PushI8,      InlineI8,           IPrimitive,  1,  0xFF,    0x21,    NEXT)
-OPDEF(CEE_LDC_R4,                     "ldc.r4",           Pop0,               PushR4,      ShortInlineR,       IPrimitive,  1,  0xFF,    0x22,    NEXT)
-OPDEF(CEE_LDC_R8,                     "ldc.r8",           Pop0,               PushR8,      InlineR,            IPrimitive,  1,  0xFF,    0x23,    NEXT)
-OPDEF(CEE_UNUSED49,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x24,    NEXT)
-OPDEF(CEE_DUP,                        "dup",              Pop1,               Push1+Push1, InlineNone,         IPrimitive,  1,  0xFF,    0x25,    NEXT)
-OPDEF(CEE_POP,                        "pop",              Pop1,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x26,    NEXT)
-OPDEF(CEE_JMP,                        "jmp",              Pop0,               Push0,       InlineMethod,       IPrimitive,  1,  0xFF,    0x27,    CALL)
-OPDEF(CEE_CALL,                       "call",             VarPop,             VarPush,     InlineMethod,       IPrimitive,  1,  0xFF,    0x28,    CALL)
-OPDEF(CEE_CALLI,                      "calli",            VarPop,             VarPush,     InlineSig,          IPrimitive,  1,  0xFF,    0x29,    CALL)
-OPDEF(CEE_RET,                        "ret",              VarPop,             Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x2A,    RETURN)
-OPDEF(CEE_BR_S,                       "br.s",             Pop0,               Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x2B,    BRANCH)
-OPDEF(CEE_BRFALSE_S,                  "brfalse.s",        PopI,               Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x2C,    COND_BRANCH)
-OPDEF(CEE_BRTRUE_S,                   "brtrue.s",         PopI,               Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x2D,    COND_BRANCH)
-OPDEF(CEE_BEQ_S,                      "beq.s",            Pop1+Pop1,          Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x2E,    COND_BRANCH)
-OPDEF(CEE_BGE_S,                      "bge.s",            Pop1+Pop1,          Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x2F,    COND_BRANCH)
-OPDEF(CEE_BGT_S,                      "bgt.s",            Pop1+Pop1,          Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x30,    COND_BRANCH)
-OPDEF(CEE_BLE_S,                      "ble.s",            Pop1+Pop1,          Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x31,    COND_BRANCH)
-OPDEF(CEE_BLT_S,                      "blt.s",            Pop1+Pop1,          Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x32,    COND_BRANCH)
-OPDEF(CEE_BNE_UN_S,                   "bne.un.s",         Pop1+Pop1,          Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x33,    COND_BRANCH)
-OPDEF(CEE_BGE_UN_S,                   "bge.un.s",         Pop1+Pop1,          Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x34,    COND_BRANCH)
-OPDEF(CEE_BGT_UN_S,                   "bgt.un.s",         Pop1+Pop1,          Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x35,    COND_BRANCH)
-OPDEF(CEE_BLE_UN_S,                   "ble.un.s",         Pop1+Pop1,          Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x36,    COND_BRANCH)
-OPDEF(CEE_BLT_UN_S,                   "blt.un.s",         Pop1+Pop1,          Push0,       ShortInlineBrTarget,IMacro,      1,  0xFF,    0x37,    COND_BRANCH)
-OPDEF(CEE_BR,                         "br",               Pop0,               Push0,       InlineBrTarget,     IPrimitive,  1,  0xFF,    0x38,    BRANCH)
-OPDEF(CEE_BRFALSE,                    "brfalse",          PopI,               Push0,       InlineBrTarget,     IPrimitive,  1,  0xFF,    0x39,    COND_BRANCH)
-OPDEF(CEE_BRTRUE,                     "brtrue",           PopI,               Push0,       InlineBrTarget,     IPrimitive,  1,  0xFF,    0x3A,    COND_BRANCH)
-OPDEF(CEE_BEQ,                        "beq",              Pop1+Pop1,          Push0,       InlineBrTarget,     IMacro,      1,  0xFF,    0x3B,    COND_BRANCH)
-OPDEF(CEE_BGE,                        "bge",              Pop1+Pop1,          Push0,       InlineBrTarget,     IMacro,      1,  0xFF,    0x3C,    COND_BRANCH)
-OPDEF(CEE_BGT,                        "bgt",              Pop1+Pop1,          Push0,       InlineBrTarget,     IMacro,      1,  0xFF,    0x3D,    COND_BRANCH)
-OPDEF(CEE_BLE,                        "ble",              Pop1+Pop1,          Push0,       InlineBrTarget,     IMacro,      1,  0xFF,    0x3E,    COND_BRANCH)
-OPDEF(CEE_BLT,                        "blt",              Pop1+Pop1,          Push0,       InlineBrTarget,     IMacro,      1,  0xFF,    0x3F,    COND_BRANCH)
-OPDEF(CEE_BNE_UN,                     "bne.un",           Pop1+Pop1,          Push0,       InlineBrTarget,     IMacro,      1,  0xFF,    0x40,    COND_BRANCH)
-OPDEF(CEE_BGE_UN,                     "bge.un",           Pop1+Pop1,          Push0,       InlineBrTarget,     IMacro,      1,  0xFF,    0x41,    COND_BRANCH)
-OPDEF(CEE_BGT_UN,                     "bgt.un",           Pop1+Pop1,          Push0,       InlineBrTarget,     IMacro,      1,  0xFF,    0x42,    COND_BRANCH)
-OPDEF(CEE_BLE_UN,                     "ble.un",           Pop1+Pop1,          Push0,       InlineBrTarget,     IMacro,      1,  0xFF,    0x43,    COND_BRANCH)
-OPDEF(CEE_BLT_UN,                     "blt.un",           Pop1+Pop1,          Push0,       InlineBrTarget,     IMacro,      1,  0xFF,    0x44,    COND_BRANCH)
-OPDEF(CEE_SWITCH,                     "switch",           PopI,               Push0,       InlineSwitch,       IPrimitive,  1,  0xFF,    0x45,    COND_BRANCH)
-OPDEF(CEE_LDIND_I1,                   "ldind.i1",         PopI,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x46,    NEXT)
-OPDEF(CEE_LDIND_U1,                   "ldind.u1",         PopI,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x47,    NEXT)
-OPDEF(CEE_LDIND_I2,                   "ldind.i2",         PopI,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x48,    NEXT)
-OPDEF(CEE_LDIND_U2,                   "ldind.u2",         PopI,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x49,    NEXT)
-OPDEF(CEE_LDIND_I4,                   "ldind.i4",         PopI,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x4A,    NEXT)
-OPDEF(CEE_LDIND_U4,                   "ldind.u4",         PopI,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x4B,    NEXT)
-OPDEF(CEE_LDIND_I8,                   "ldind.i8",         PopI,               PushI8,      InlineNone,         IPrimitive,  1,  0xFF,    0x4C,    NEXT)
-OPDEF(CEE_LDIND_I,                    "ldind.i",          PopI,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x4D,    NEXT)
-OPDEF(CEE_LDIND_R4,                   "ldind.r4",         PopI,               PushR4,      InlineNone,         IPrimitive,  1,  0xFF,    0x4E,    NEXT)
-OPDEF(CEE_LDIND_R8,                   "ldind.r8",         PopI,               PushR8,      InlineNone,         IPrimitive,  1,  0xFF,    0x4F,    NEXT)
-OPDEF(CEE_LDIND_REF,                  "ldind.ref",        PopI,               PushRef,     InlineNone,         IPrimitive,  1,  0xFF,    0x50,    NEXT)
-OPDEF(CEE_STIND_REF,                  "stind.ref",        PopI+PopI,          Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x51,    NEXT)
-OPDEF(CEE_STIND_I1,                   "stind.i1",         PopI+PopI,          Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x52,    NEXT)
-OPDEF(CEE_STIND_I2,                   "stind.i2",         PopI+PopI,          Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x53,    NEXT)
-OPDEF(CEE_STIND_I4,                   "stind.i4",         PopI+PopI,          Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x54,    NEXT)
-OPDEF(CEE_STIND_I8,                   "stind.i8",         PopI+PopI8,         Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x55,    NEXT)
-OPDEF(CEE_STIND_R4,                   "stind.r4",         PopI+PopR4,         Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x56,    NEXT)
-OPDEF(CEE_STIND_R8,                   "stind.r8",         PopI+PopR8,         Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x57,    NEXT)
-OPDEF(CEE_ADD,                        "add",              Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x58,    NEXT)
-OPDEF(CEE_SUB,                        "sub",              Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x59,    NEXT)
-OPDEF(CEE_MUL,                        "mul",              Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x5A,    NEXT)
-OPDEF(CEE_DIV,                        "div",              Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x5B,    NEXT)
-OPDEF(CEE_DIV_UN,                     "div.un",           Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x5C,    NEXT)
-OPDEF(CEE_REM,                        "rem",              Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x5D,    NEXT)
-OPDEF(CEE_REM_UN,                     "rem.un",           Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x5E,    NEXT)
-OPDEF(CEE_AND,                        "and",              Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x5F,    NEXT)
-OPDEF(CEE_OR,                         "or",               Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x60,    NEXT)
-OPDEF(CEE_XOR,                        "xor",              Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x61,    NEXT)
-OPDEF(CEE_SHL,                        "shl",              Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x62,    NEXT)
-OPDEF(CEE_SHR,                        "shr",              Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x63,    NEXT)
-OPDEF(CEE_SHR_UN,                     "shr.un",           Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x64,    NEXT)
-OPDEF(CEE_NEG,                        "neg",              Pop1,               Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x65,    NEXT)
-OPDEF(CEE_NOT,                        "not",              Pop1,               Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0x66,    NEXT)
-OPDEF(CEE_CONV_I1,                    "conv.i1",          Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x67,    NEXT)
-OPDEF(CEE_CONV_I2,                    "conv.i2",          Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x68,    NEXT)
-OPDEF(CEE_CONV_I4,                    "conv.i4",          Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x69,    NEXT)
-OPDEF(CEE_CONV_I8,                    "conv.i8",          Pop1,               PushI8,      InlineNone,         IPrimitive,  1,  0xFF,    0x6A,    NEXT)
-OPDEF(CEE_CONV_R4,                    "conv.r4",          Pop1,               PushR4,      InlineNone,         IPrimitive,  1,  0xFF,    0x6B,    NEXT)
-OPDEF(CEE_CONV_R8,                    "conv.r8",          Pop1,               PushR8,      InlineNone,         IPrimitive,  1,  0xFF,    0x6C,    NEXT)
-OPDEF(CEE_CONV_U4,                    "conv.u4",          Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x6D,    NEXT)
-OPDEF(CEE_CONV_U8,                    "conv.u8",          Pop1,               PushI8,      InlineNone,         IPrimitive,  1,  0xFF,    0x6E,    NEXT)
-OPDEF(CEE_CALLVIRT,                   "callvirt",         VarPop,             VarPush,     InlineMethod,       IObjModel,   1,  0xFF,    0x6F,    CALL)
-OPDEF(CEE_CPOBJ,                      "cpobj",            PopI+PopI,          Push0,       InlineType,         IObjModel,   1,  0xFF,    0x70,    NEXT)
-OPDEF(CEE_LDOBJ,                      "ldobj",            PopI,               Push1,       InlineType,         IObjModel,   1,  0xFF,    0x71,    NEXT)
-OPDEF(CEE_LDSTR,                      "ldstr",            Pop0,               PushRef,     InlineString,       IObjModel,   1,  0xFF,    0x72,    NEXT)
-OPDEF(CEE_NEWOBJ,                     "newobj",           VarPop,             PushRef,     InlineMethod,       IObjModel,   1,  0xFF,    0x73,    CALL)
-OPDEF(CEE_CASTCLASS,                  "castclass",        PopRef,             PushRef,     InlineType,         IObjModel,   1,  0xFF,    0x74,    NEXT)
-OPDEF(CEE_ISINST,                     "isinst",           PopRef,             PushI,       InlineType,         IObjModel,   1,  0xFF,    0x75,    NEXT)
-OPDEF(CEE_CONV_R_UN,                  "conv.r.un",        Pop1,               PushR8,      InlineNone,         IPrimitive,  1,  0xFF,    0x76,    NEXT)
-OPDEF(CEE_UNUSED58,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x77,    NEXT)
-OPDEF(CEE_UNUSED1,                    "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0x78,    NEXT)
-OPDEF(CEE_UNBOX,                      "unbox",            PopRef,             PushI,       InlineType,         IPrimitive,  1,  0xFF,    0x79,    NEXT)
-OPDEF(CEE_THROW,                      "throw",            PopRef,             Push0,       InlineNone,         IObjModel,   1,  0xFF,    0x7A,    THROW)
-OPDEF(CEE_LDFLD,                      "ldfld",            PopRef,             Push1,       InlineField,        IObjModel,   1,  0xFF,    0x7B,    NEXT)
-OPDEF(CEE_LDFLDA,                     "ldflda",           PopRef,             PushI,       InlineField,        IObjModel,   1,  0xFF,    0x7C,    NEXT)
-OPDEF(CEE_STFLD,                      "stfld",            PopRef+Pop1,        Push0,       InlineField,        IObjModel,   1,  0xFF,    0x7D,    NEXT)
-OPDEF(CEE_LDSFLD,                     "ldsfld",           Pop0,               Push1,       InlineField,        IObjModel,   1,  0xFF,    0x7E,    NEXT)
-OPDEF(CEE_LDSFLDA,                    "ldsflda",          Pop0,               PushI,       InlineField,        IObjModel,   1,  0xFF,    0x7F,    NEXT)
-OPDEF(CEE_STSFLD,                     "stsfld",           Pop1,               Push0,       InlineField,        IObjModel,   1,  0xFF,    0x80,    NEXT)
-OPDEF(CEE_STOBJ,                      "stobj",            PopI+Pop1,          Push0,       InlineType,         IPrimitive,  1,  0xFF,    0x81,    NEXT)
-OPDEF(CEE_CONV_OVF_I1_UN,             "conv.ovf.i1.un",   Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x82,    NEXT)
-OPDEF(CEE_CONV_OVF_I2_UN,             "conv.ovf.i2.un",   Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x83,    NEXT)
-OPDEF(CEE_CONV_OVF_I4_UN,             "conv.ovf.i4.un",   Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x84,    NEXT)
-OPDEF(CEE_CONV_OVF_I8_UN,             "conv.ovf.i8.un",   Pop1,               PushI8,      InlineNone,         IPrimitive,  1,  0xFF,    0x85,    NEXT)
-OPDEF(CEE_CONV_OVF_U1_UN,             "conv.ovf.u1.un",   Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x86,    NEXT)
-OPDEF(CEE_CONV_OVF_U2_UN,             "conv.ovf.u2.un",   Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x87,    NEXT)
-OPDEF(CEE_CONV_OVF_U4_UN,             "conv.ovf.u4.un",   Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x88,    NEXT)
-OPDEF(CEE_CONV_OVF_U8_UN,             "conv.ovf.u8.un",   Pop1,               PushI8,      InlineNone,         IPrimitive,  1,  0xFF,    0x89,    NEXT)
-OPDEF(CEE_CONV_OVF_I_UN,              "conv.ovf.i.un",    Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x8A,    NEXT)
-OPDEF(CEE_CONV_OVF_U_UN,              "conv.ovf.u.un",    Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0x8B,    NEXT)
-OPDEF(CEE_BOX,                        "box",              Pop1,               PushRef,     InlineType,         IPrimitive,  1,  0xFF,    0x8C,    NEXT)
-OPDEF(CEE_NEWARR,                     "newarr",           PopI,               PushRef,     InlineType,         IObjModel,   1,  0xFF,    0x8D,    NEXT)
-OPDEF(CEE_LDLEN,                      "ldlen",            PopRef,             PushI,       InlineNone,         IObjModel,   1,  0xFF,    0x8E,    NEXT)
-OPDEF(CEE_LDELEMA,                    "ldelema",          PopRef+PopI,        PushI,       InlineType,         IObjModel,   1,  0xFF,    0x8F,    NEXT)
-OPDEF(CEE_LDELEM_I1,                  "ldelem.i1",        PopRef+PopI,        PushI,       InlineNone,         IObjModel,   1,  0xFF,    0x90,    NEXT)
-OPDEF(CEE_LDELEM_U1,                  "ldelem.u1",        PopRef+PopI,        PushI,       InlineNone,         IObjModel,   1,  0xFF,    0x91,    NEXT)
-OPDEF(CEE_LDELEM_I2,                  "ldelem.i2",        PopRef+PopI,        PushI,       InlineNone,         IObjModel,   1,  0xFF,    0x92,    NEXT)
-OPDEF(CEE_LDELEM_U2,                  "ldelem.u2",        PopRef+PopI,        PushI,       InlineNone,         IObjModel,   1,  0xFF,    0x93,    NEXT)
-OPDEF(CEE_LDELEM_I4,                  "ldelem.i4",        PopRef+PopI,        PushI,       InlineNone,         IObjModel,   1,  0xFF,    0x94,    NEXT)
-OPDEF(CEE_LDELEM_U4,                  "ldelem.u4",        PopRef+PopI,        PushI,       InlineNone,         IObjModel,   1,  0xFF,    0x95,    NEXT)
-OPDEF(CEE_LDELEM_I8,                  "ldelem.i8",        PopRef+PopI,        PushI8,      InlineNone,         IObjModel,   1,  0xFF,    0x96,    NEXT)
-OPDEF(CEE_LDELEM_I,                   "ldelem.i",         PopRef+PopI,        PushI,       InlineNone,         IObjModel,   1,  0xFF,    0x97,    NEXT)
-OPDEF(CEE_LDELEM_R4,                  "ldelem.r4",        PopRef+PopI,        PushR4,      InlineNone,         IObjModel,   1,  0xFF,    0x98,    NEXT)
-OPDEF(CEE_LDELEM_R8,                  "ldelem.r8",        PopRef+PopI,        PushR8,      InlineNone,         IObjModel,   1,  0xFF,    0x99,    NEXT)
-OPDEF(CEE_LDELEM_REF,                 "ldelem.ref",       PopRef+PopI,        PushRef,     InlineNone,         IObjModel,   1,  0xFF,    0x9A,    NEXT)
-OPDEF(CEE_STELEM_I,                   "stelem.i",         PopRef+PopI+PopI,   Push0,       InlineNone,         IObjModel,   1,  0xFF,    0x9B,    NEXT)
-OPDEF(CEE_STELEM_I1,                  "stelem.i1",        PopRef+PopI+PopI,   Push0,       InlineNone,         IObjModel,   1,  0xFF,    0x9C,    NEXT)
-OPDEF(CEE_STELEM_I2,                  "stelem.i2",        PopRef+PopI+PopI,   Push0,       InlineNone,         IObjModel,   1,  0xFF,    0x9D,    NEXT)
-OPDEF(CEE_STELEM_I4,                  "stelem.i4",        PopRef+PopI+PopI,   Push0,       InlineNone,         IObjModel,   1,  0xFF,    0x9E,    NEXT)
-OPDEF(CEE_STELEM_I8,                  "stelem.i8",        PopRef+PopI+PopI8,  Push0,       InlineNone,         IObjModel,   1,  0xFF,    0x9F,    NEXT)
-OPDEF(CEE_STELEM_R4,                  "stelem.r4",        PopRef+PopI+PopR4,  Push0,       InlineNone,         IObjModel,   1,  0xFF,    0xA0,    NEXT)
-OPDEF(CEE_STELEM_R8,                  "stelem.r8",        PopRef+PopI+PopR8,  Push0,       InlineNone,         IObjModel,   1,  0xFF,    0xA1,    NEXT)
-OPDEF(CEE_STELEM_REF,                 "stelem.ref",       PopRef+PopI+PopRef, Push0,       InlineNone,         IObjModel,   1,  0xFF,    0xA2,    NEXT)
-OPDEF(CEE_LDELEM,                     "ldelem",           PopRef+PopI,        Push1,       InlineType,         IObjModel,   1,  0xFF,    0xA3,    NEXT)
-OPDEF(CEE_STELEM,                     "stelem",           PopRef+PopI+Pop1,   Push0,       InlineType,         IObjModel,   1,  0xFF,    0xA4,    NEXT)
-OPDEF(CEE_UNBOX_ANY,                  "unbox.any",        PopRef,             Push1,       InlineType,         IObjModel,   1,  0xFF,    0xA5,    NEXT)
-OPDEF(CEE_UNUSED5,                    "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xA6,    NEXT)
-OPDEF(CEE_UNUSED6,                    "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xA7,    NEXT)
-OPDEF(CEE_UNUSED7,                    "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xA8,    NEXT)
-OPDEF(CEE_UNUSED8,                    "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xA9,    NEXT)
-OPDEF(CEE_UNUSED9,                    "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xAA,    NEXT)
-OPDEF(CEE_UNUSED10,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xAB,    NEXT)
-OPDEF(CEE_UNUSED11,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xAC,    NEXT)
-OPDEF(CEE_UNUSED12,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xAD,    NEXT)
-OPDEF(CEE_UNUSED13,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xAE,    NEXT)
-OPDEF(CEE_UNUSED14,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xAF,    NEXT)
-OPDEF(CEE_UNUSED15,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xB0,    NEXT)
-OPDEF(CEE_UNUSED16,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xB1,    NEXT)
-OPDEF(CEE_UNUSED17,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xB2,    NEXT)
-OPDEF(CEE_CONV_OVF_I1,                "conv.ovf.i1",      Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xB3,    NEXT)
-OPDEF(CEE_CONV_OVF_U1,                "conv.ovf.u1",      Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xB4,    NEXT)
-OPDEF(CEE_CONV_OVF_I2,                "conv.ovf.i2",      Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xB5,    NEXT)
-OPDEF(CEE_CONV_OVF_U2,                "conv.ovf.u2",      Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xB6,    NEXT)
-OPDEF(CEE_CONV_OVF_I4,                "conv.ovf.i4",      Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xB7,    NEXT)
-OPDEF(CEE_CONV_OVF_U4,                "conv.ovf.u4",      Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xB8,    NEXT)
-OPDEF(CEE_CONV_OVF_I8,                "conv.ovf.i8",      Pop1,               PushI8,      InlineNone,         IPrimitive,  1,  0xFF,    0xB9,    NEXT)
-OPDEF(CEE_CONV_OVF_U8,                "conv.ovf.u8",      Pop1,               PushI8,      InlineNone,         IPrimitive,  1,  0xFF,    0xBA,    NEXT)
-OPDEF(CEE_UNUSED50,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xBB,    NEXT)
-OPDEF(CEE_UNUSED18,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xBC,    NEXT)
-OPDEF(CEE_UNUSED19,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xBD,    NEXT)
-OPDEF(CEE_UNUSED20,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xBE,    NEXT)
-OPDEF(CEE_UNUSED21,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xBF,    NEXT)
-OPDEF(CEE_UNUSED22,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xC0,    NEXT)
-OPDEF(CEE_UNUSED23,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xC1,    NEXT)
-OPDEF(CEE_REFANYVAL,                  "refanyval",        Pop1,               PushI,       InlineType,         IPrimitive,  1,  0xFF,    0xC2,    NEXT)
-OPDEF(CEE_CKFINITE,                   "ckfinite",         Pop1,               PushR8,      InlineNone,         IPrimitive,  1,  0xFF,    0xC3,    NEXT)
-OPDEF(CEE_UNUSED24,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xC4,    NEXT)
-OPDEF(CEE_UNUSED25,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xC5,    NEXT)
-OPDEF(CEE_MKREFANY,                   "mkrefany",         PopI,               Push1,       InlineType,         IPrimitive,  1,  0xFF,    0xC6,    NEXT)
-OPDEF(CEE_UNUSED59,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xC7,    NEXT)
-OPDEF(CEE_UNUSED60,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xC8,    NEXT)
-OPDEF(CEE_UNUSED61,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xC9,    NEXT)
-OPDEF(CEE_UNUSED62,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xCA,    NEXT)
-OPDEF(CEE_UNUSED63,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xCB,    NEXT)
-OPDEF(CEE_UNUSED64,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xCC,    NEXT)
-OPDEF(CEE_UNUSED65,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xCD,    NEXT)
-OPDEF(CEE_UNUSED66,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xCE,    NEXT)
-OPDEF(CEE_UNUSED67,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xCF,    NEXT)
-OPDEF(CEE_LDTOKEN,                    "ldtoken",          Pop0,               PushI,       InlineTok,          IPrimitive,  1,  0xFF,    0xD0,    NEXT)
-OPDEF(CEE_CONV_U2,                    "conv.u2",          Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xD1,    NEXT)
-OPDEF(CEE_CONV_U1,                    "conv.u1",          Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xD2,    NEXT)
-OPDEF(CEE_CONV_I,                     "conv.i",           Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xD3,    NEXT)
-OPDEF(CEE_CONV_OVF_I,                 "conv.ovf.i",       Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xD4,    NEXT)
-OPDEF(CEE_CONV_OVF_U,                 "conv.ovf.u",       Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xD5,    NEXT)
-OPDEF(CEE_ADD_OVF,                    "add.ovf",          Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0xD6,    NEXT)
-OPDEF(CEE_ADD_OVF_UN,                 "add.ovf.un",       Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0xD7,    NEXT)
-OPDEF(CEE_MUL_OVF,                    "mul.ovf",          Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0xD8,    NEXT)
-OPDEF(CEE_MUL_OVF_UN,                 "mul.ovf.un",       Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0xD9,    NEXT)
-OPDEF(CEE_SUB_OVF,                    "sub.ovf",          Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0xDA,    NEXT)
-OPDEF(CEE_SUB_OVF_UN,                 "sub.ovf.un",       Pop1+Pop1,          Push1,       InlineNone,         IPrimitive,  1,  0xFF,    0xDB,    NEXT)
-OPDEF(CEE_ENDFINALLY,                 "endfinally",       Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xDC,    RETURN)
-OPDEF(CEE_LEAVE,                      "leave",            Pop0,               Push0,       InlineBrTarget,     IPrimitive,  1,  0xFF,    0xDD,    BRANCH)
-OPDEF(CEE_LEAVE_S,                    "leave.s",          Pop0,               Push0,       ShortInlineBrTarget,IPrimitive,  1,  0xFF,    0xDE,    BRANCH)
-OPDEF(CEE_STIND_I,                    "stind.i",          PopI+PopI,          Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xDF,    NEXT)
-OPDEF(CEE_CONV_U,                     "conv.u",           Pop1,               PushI,       InlineNone,         IPrimitive,  1,  0xFF,    0xE0,    NEXT)
-OPDEF(CEE_UNUSED26,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xE1,    NEXT)
-OPDEF(CEE_UNUSED27,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xE2,    NEXT)
-OPDEF(CEE_UNUSED28,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xE3,    NEXT)
-OPDEF(CEE_UNUSED29,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xE4,    NEXT)
-OPDEF(CEE_UNUSED30,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xE5,    NEXT)
-OPDEF(CEE_UNUSED31,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xE6,    NEXT)
-OPDEF(CEE_UNUSED32,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xE7,    NEXT)
-OPDEF(CEE_UNUSED33,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xE8,    NEXT)
-OPDEF(CEE_UNUSED34,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xE9,    NEXT)
-OPDEF(CEE_UNUSED35,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xEA,    NEXT)
-OPDEF(CEE_UNUSED36,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xEB,    NEXT)
-OPDEF(CEE_UNUSED37,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xEC,    NEXT)
-OPDEF(CEE_UNUSED38,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xED,    NEXT)
-OPDEF(CEE_UNUSED39,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xEE,    NEXT)
-OPDEF(CEE_UNUSED40,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xEF,    NEXT)
-OPDEF(CEE_UNUSED41,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xF0,    NEXT)
-OPDEF(CEE_UNUSED42,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xF1,    NEXT)
-OPDEF(CEE_UNUSED43,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xF2,    NEXT)
-OPDEF(CEE_UNUSED44,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xF3,    NEXT)
-OPDEF(CEE_UNUSED45,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xF4,    NEXT)
-OPDEF(CEE_UNUSED46,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xF5,    NEXT)
-OPDEF(CEE_UNUSED47,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xF6,    NEXT)
-OPDEF(CEE_UNUSED48,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  1,  0xFF,    0xF7,    NEXT)
-OPDEF(CEE_PREFIX7,                    "prefix7",          Pop0,               Push0,       InlineNone,         IInternal,   1,  0xFF,    0xF8,    META)
-OPDEF(CEE_PREFIX6,                    "prefix6",          Pop0,               Push0,       InlineNone,         IInternal,   1,  0xFF,    0xF9,    META)
-OPDEF(CEE_PREFIX5,                    "prefix5",          Pop0,               Push0,       InlineNone,         IInternal,   1,  0xFF,    0xFA,    META)
-OPDEF(CEE_PREFIX4,                    "prefix4",          Pop0,               Push0,       InlineNone,         IInternal,   1,  0xFF,    0xFB,    META)
-OPDEF(CEE_PREFIX3,                    "prefix3",          Pop0,               Push0,       InlineNone,         IInternal,   1,  0xFF,    0xFC,    META)
-OPDEF(CEE_PREFIX2,                    "prefix2",          Pop0,               Push0,       InlineNone,         IInternal,   1,  0xFF,    0xFD,    META)
-OPDEF(CEE_PREFIX1,                    "prefix1",          Pop0,               Push0,       InlineNone,         IInternal,   1,  0xFF,    0xFE,    META)
-OPDEF(CEE_PREFIXREF,                  "prefixref",        Pop0,               Push0,       InlineNone,         IInternal,   1,  0xFF,    0xFF,    META)
-
-OPDEF(CEE_ARGLIST,                    "arglist",          Pop0,               PushI,       InlineNone,         IPrimitive,  2,  0xFE,    0x00,    NEXT)
-OPDEF(CEE_CEQ,                        "ceq",              Pop1+Pop1,          PushI,       InlineNone,         IPrimitive,  2,  0xFE,    0x01,    NEXT)
-OPDEF(CEE_CGT,                        "cgt",              Pop1+Pop1,          PushI,       InlineNone,         IPrimitive,  2,  0xFE,    0x02,    NEXT)
-OPDEF(CEE_CGT_UN,                     "cgt.un",           Pop1+Pop1,          PushI,       InlineNone,         IPrimitive,  2,  0xFE,    0x03,    NEXT)
-OPDEF(CEE_CLT,                        "clt",              Pop1+Pop1,          PushI,       InlineNone,         IPrimitive,  2,  0xFE,    0x04,    NEXT)
-OPDEF(CEE_CLT_UN,                     "clt.un",           Pop1+Pop1,          PushI,       InlineNone,         IPrimitive,  2,  0xFE,    0x05,    NEXT)
-OPDEF(CEE_LDFTN,                      "ldftn",            Pop0,               PushI,       InlineMethod,       IPrimitive,  2,  0xFE,    0x06,    NEXT)
-OPDEF(CEE_LDVIRTFTN,                  "ldvirtftn",        PopRef,             PushI,       InlineMethod,       IPrimitive,  2,  0xFE,    0x07,    NEXT)
-OPDEF(CEE_UNUSED56,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  2,  0xFE,    0x08,    NEXT)
-OPDEF(CEE_LDARG,                      "ldarg",            Pop0,               Push1,       InlineVar,          IPrimitive,  2,  0xFE,    0x09,    NEXT)
-OPDEF(CEE_LDARGA,                     "ldarga",           Pop0,               PushI,       InlineVar,          IPrimitive,  2,  0xFE,    0x0A,    NEXT)
-OPDEF(CEE_STARG,                      "starg",            Pop1,               Push0,       InlineVar,          IPrimitive,  2,  0xFE,    0x0B,    NEXT)
-OPDEF(CEE_LDLOC,                      "ldloc",            Pop0,               Push1,       InlineVar,          IPrimitive,  2,  0xFE,    0x0C,    NEXT)
-OPDEF(CEE_LDLOCA,                     "ldloca",           Pop0,               PushI,       InlineVar,          IPrimitive,  2,  0xFE,    0x0D,    NEXT)
-OPDEF(CEE_STLOC,                      "stloc",            Pop1,               Push0,       InlineVar,          IPrimitive,  2,  0xFE,    0x0E,    NEXT)
-OPDEF(CEE_LOCALLOC,                   "localloc",         PopI,               PushI,       InlineNone,         IPrimitive,  2,  0xFE,    0x0F,    NEXT)
-OPDEF(CEE_UNUSED57,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  2,  0xFE,    0x10,    NEXT)
-OPDEF(CEE_ENDFILTER,                  "endfilter",        PopI,               Push0,       InlineNone,         IPrimitive,  2,  0xFE,    0x11,    RETURN)
-OPDEF(CEE_UNALIGNED,                  "unaligned.",       Pop0,               Push0,       ShortInlineI,       IPrefix,     2,  0xFE,    0x12,    META)
-OPDEF(CEE_VOLATILE,                   "volatile.",        Pop0,               Push0,       InlineNone,         IPrefix,     2,  0xFE,    0x13,    META)
-OPDEF(CEE_TAILCALL,                   "tail.",            Pop0,               Push0,       InlineNone,         IPrefix,     2,  0xFE,    0x14,    META)
-OPDEF(CEE_INITOBJ,                    "initobj",          PopI,               Push0,       InlineType,         IObjModel,   2,  0xFE,    0x15,    NEXT)
-OPDEF(CEE_CONSTRAINED,                "constrained.",     Pop0,               Push0,       InlineType,         IPrefix,     2,  0xFE,    0x16,    META)
-OPDEF(CEE_CPBLK,                      "cpblk",            PopI+PopI+PopI,     Push0,       InlineNone,         IPrimitive,  2,  0xFE,    0x17,    NEXT)
-OPDEF(CEE_INITBLK,                    "initblk",          PopI+PopI+PopI,     Push0,       InlineNone,         IPrimitive,  2,  0xFE,    0x18,    NEXT)
-OPDEF(CEE_UNUSED69,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  2,  0xFE,    0x19,    NEXT)
-OPDEF(CEE_RETHROW,                    "rethrow",          Pop0,               Push0,       InlineNone,         IObjModel,   2,  0xFE,    0x1A,    THROW)
-OPDEF(CEE_UNUSED51,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  2,  0xFE,    0x1B,    NEXT)
-OPDEF(CEE_SIZEOF,                     "sizeof",           Pop0,               PushI,       InlineType,         IPrimitive,  2,  0xFE,    0x1C,    NEXT)
-OPDEF(CEE_REFANYTYPE,                 "refanytype",       Pop1,               PushI,       InlineNone,         IPrimitive,  2,  0xFE,    0x1D,    NEXT)
-OPDEF(CEE_READONLY,                   "readonly.",        Pop0,               Push0,       InlineNone,         IPrefix,     2,  0xFE,    0x1E,    META)
-OPDEF(CEE_UNUSED53,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  2,  0xFE,    0x1F,    NEXT)
-OPDEF(CEE_UNUSED54,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  2,  0xFE,    0x20,    NEXT)
-OPDEF(CEE_UNUSED55,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  2,  0xFE,    0x21,    NEXT)
-OPDEF(CEE_UNUSED70,                   "unused",           Pop0,               Push0,       InlineNone,         IPrimitive,  2,  0xFE,    0x22,    NEXT)
-
-// These are not real opcodes, but they are handy internally in the EE
-
-OPDEF(CEE_ILLEGAL,                    "illegal",          Pop0,               Push0,       InlineNone,         IInternal,   0,  MOOT,    MOOT,    META)
-OPDEF(CEE_MACRO_END,                  "endmac",           Pop0,               Push0,       InlineNone,         IInternal,   0,  MOOT,    MOOT,    META)
-OPDEF(CEE_CODE_LABEL,                 "codelabel",        Pop0,               Push0,       InlineNone,         IInternal,   0,  MOOT,    MOOT,    META)
-
-#ifndef OPALIAS
-#define _OPALIAS_DEFINED_
-#define OPALIAS(canonicalName, stringName, realOpcode)
-#endif
-
-OPALIAS(CEE_BRNULL,        "brnull",            CEE_BRFALSE)
-OPALIAS(CEE_BRNULL_S,      "brnull.s",          CEE_BRFALSE_S)
-OPALIAS(CEE_BRZERO,        "brzero",            CEE_BRFALSE)
-OPALIAS(CEE_BRZERO_S,      "brzero.s",          CEE_BRFALSE_S)
-OPALIAS(CEE_BRINST,        "brinst",            CEE_BRTRUE)
-OPALIAS(CEE_BRINST_S,      "brinst.s",          CEE_BRTRUE_S)
-OPALIAS(CEE_LDIND_U8,      "ldind.u8",          CEE_LDIND_I8)
-OPALIAS(CEE_LDELEM_U8,     "ldelem.u8",         CEE_LDELEM_I8)
-OPALIAS(CEE_LDELEM_ANY,    "ldelem.any",        CEE_LDELEM)
-OPALIAS(CEE_STELEM_ANY,    "stelem.any",        CEE_STELEM)
-OPALIAS(CEE_LDC_I4_M1x,    "ldc.i4.M1",         CEE_LDC_I4_M1)
-OPALIAS(CEE_ENDFAULT,      "endfault",          CEE_ENDFINALLY)
-
-#ifdef _OPALIAS_DEFINED_
-#undef OPALIAS
-#undef _OPALIAS_DEFINED_
-#endif
-

src/natsuclr/include/vm/openum.h

@@ -1,51 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#ifndef __openum_h__
-#define __openum_h__
-
-
-typedef enum opcode_t
-{
-#define OPDEF(c,s,pop,push,args,type,l,s1,s2,ctrl) c,
-#include "opcode.def"
-#undef OPDEF
-  CEE_COUNT,        /* number of instructions and macros pre-defined */
-} OPCODE;
-
-
-typedef enum opcode_format_t 
-{
-	InlineNone		= 0,	// no inline args       
-	InlineVar		= 1,	// local variable       (U2 (U1 if Short on))
-	InlineI			= 2,	// an signed integer    (I4 (I1 if Short on))
-	InlineR			= 3,	// a real number        (R8 (R4 if Short on))
-	InlineBrTarget	= 4,    // branch target        (I4 (I1 if Short on))
-	InlineI8		= 5,
-	InlineMethod	= 6,   // method token (U4)
-	InlineField		= 7,   // field token  (U4)
-	InlineType		= 8,   // type token   (U4)
-	InlineString	= 9,   // string TOKEN (U4)
-	InlineSig		= 10,  // signature tok (U4)
-	InlineRVA		= 11,  // ldptr token  (U4)
-	InlineTok		= 12,  // a meta-data token of unknown type (U4)
-	InlineSwitch	= 13,  // count (U4), pcrel1 (U4) .... pcrelN (U4)
-	InlinePhi		= 14,  // count (U1), var1 (U2) ... varN (U2) 
-
-	// WATCH OUT we are close to the limit here, if you add
-	// more enumerations you need to change ShortIline definition below
-
-	// The extended enumeration also encodes the size in the IL stream
-	ShortInline 	= 16,						// if this bit is set, the format is the 'short' format
-	PrimaryMask   	= (ShortInline-1),			// mask these off to get primary enumeration above
-	ShortInlineVar 	= (ShortInline + InlineVar),
-	ShortInlineI	= (ShortInline + InlineI),
-	ShortInlineR	= (ShortInline + InlineR),
-	ShortInlineBrTarget = (ShortInline + InlineBrTarget),
-	InlineOpcode	= (ShortInline + InlineNone),    // This is only used internally.  It means the 'opcode' is two byte instead of 1
-} OPCODE_FORMAT;
-
-#endif /* __openum_h__ */
-
-

src/natsuclr/include/vm/opinfo.h

@@ -1,85 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-
-/***************************************************************************/
-/*                                OpInfo.h                                 */
-/***************************************************************************/
-
-/* contains OpInfo, a wrapper that allows you to get useful information
-   about IL opcodes, and how to decode them */
-
-/***************************************************************************/
-
-#ifndef OpInfo_h
-#define OpInfo_h
-
-#include "openum.h"
-#include <cassert>
-#include <cstdint>
-
-	// Decribes the flow of control properties of the instruction
-enum OpFlow {
-	FLOW_META,			// not a real instuction
-	FLOW_CALL,			// a call instruction
-	FLOW_BRANCH,			// unconditional branch, does not fall through
-	FLOW_COND_BRANCH,	// may fall through
-	FLOW_PHI,			
-	FLOW_THROW,
-	FLOW_BREAK,
-	FLOW_RETURN,		
-	FLOW_NEXT,			// flows into next instruction (none of the above)
-};
-
-	// These are all the possible arguments for the instruction
-/****************************************************************************/
-union OpArgsVal {
-	int32_t  i;
-	int64_t i8;
-	double   r;
-	struct {
-		unsigned count;
-		int* targets;   // targets are pcrelative displacements (little-endian)
-		} switch_;
-	struct {
-		unsigned count;
-		unsigned short* vars;
-		} phi;
-};
-
-/***************************************************************************/
-
-	// OpInfo parses a il instrution into an opcode, and a arg and updates the IP
-class OpInfo {
-public:
-	OpInfo()			  { data = 0; }
-	OpInfo(OPCODE opCode) { assert(opCode < CEE_COUNT); data = &table[opCode]; } 
-
-		// fetch instruction at 'instrPtr, fills in 'args' returns pointer 
-		// to next instruction 
-	const uint8_t* fetch(const uint8_t* instrPtr, OpArgsVal* args);
-
-	const char* getName() 	 	{ return(data->name); }
-	OPCODE_FORMAT getArgsInfo()	{ return(OPCODE_FORMAT(data->format & PrimaryMask)); }
-	OpFlow 		getFlow()	 	{ return(data->flow); }
-	OPCODE 		getOpcode()	 	{ return((OPCODE) (data-table)); }
-    int         getNumPop()     { return(data->numPop); }
-    int         getNumPush()    { return(data->numPush); }
-
-private:
-	struct OpInfoData {
-        const char* name;
-        OPCODE_FORMAT format  	: 8;
-		OpFlow     	flow		: 8;
-		int     	numPop		: 3;	// < 0 means depends on instr args
-		int       	numPush		: 3;	// < 0 means depends on instr args
-        OPCODE      opcode      : 10;  	// This is the same as the index into the table
-    };
-
-	static OpInfoData table[];
-private:
-	OpInfoData* data;
-};
-
-#endif

src/natsuclr/loader/AssemblyFile.cpp

@@ -1,216 +0,0 @@
-//
-// Natsu CLR Loader
-//
-#include <loader/AssemblyFile.hpp>
-#include <utils.hpp>
-#include <cstring>
-
-using namespace clr::loader;
-
-#pragma pack(push, 4)
-
-#define IMAGE_DOS_SIGNATURE                 0x5A4D      // MZ
-#define IMAGE_NT_SIGNATURE                  0x00004550  // PE00
-#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES    16
-#define IMAGE_FILE_MACHINE_CEE              0xC0EE
-
-#define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14   // COM Runtime descriptor
-
-// DOS .EXE header
-struct IMAGE_DOS_HEADER
-{
-	uint16_t   e_magic;                     // Magic number
-	uint16_t   e_cblp;                      // Bytes on last page of file
-	uint16_t   e_cp;                        // Pages in file
-	uint16_t   e_crlc;                      // Relocations
-	uint16_t   e_cparhdr;                   // Size of header in paragraphs
-	uint16_t   e_minalloc;                  // Minimum extra paragraphs needed
-	uint16_t   e_maxalloc;                  // Maximum extra paragraphs needed
-	uint16_t   e_ss;                        // Initial (relative) SS value
-	uint16_t   e_sp;                        // Initial SP value
-	uint16_t   e_csum;                      // Checksum
-	uint16_t   e_ip;                        // Initial IP value
-	uint16_t   e_cs;                        // Initial (relative) CS value
-	uint16_t   e_lfarlc;                    // File address of relocation table
-	uint16_t   e_ovno;                      // Overlay number
-	uint16_t   e_res[4];                    // Reserved words
-	uint16_t   e_oemid;                     // OEM identifier (for e_oeminfo)
-	uint16_t   e_oeminfo;                   // OEM information; e_oemid specific
-	uint16_t   e_res2[10];                  // Reserved words
-	uint32_t   e_lfanew;                    // File address of new exe header
-};
-
-struct IMAGE_FILE_HEADER
-{
-	uint16_t   Machine;
-	uint16_t   NumberOfSections;
-	uint32_t   TimeDateStamp;
-	uint32_t   PointerToSymbolTable;
-	uint32_t   NumberOfSymbols;
-	uint16_t   SizeOfOptionalHeader;
-	uint16_t   Characteristics;
-};
-
-struct IMAGE_DATA_DIRECTORY
-{
-	uint32_t   VirtualAddress;
-	uint32_t   Size;
-};
-
-struct IMAGE_OPTIONAL_HEADER32
-{
-	//
-	// Standard fields.
-	//
-
-	uint16_t   Magic;
-	uint8_t    MajorLinkerVersion;
-	uint8_t    MinorLinkerVersion;
-	uint32_t   SizeOfCode;
-	uint32_t   SizeOfInitializedData;
-	uint32_t   SizeOfUninitializedData;
-	uint32_t   AddressOfEntryPoint;
-	uint32_t   BaseOfCode;
-	uint32_t   BaseOfData;
-
-	//
-	// NT additional fields.
-	//
-
-	uint32_t   ImageBase;
-	uint32_t   SectionAlignment;
-	uint32_t   FileAlignment;
-	uint16_t   MajorOperatingSystemVersion;
-	uint16_t   MinorOperatingSystemVersion;
-	uint16_t   MajorImageVersion;
-	uint16_t   MinorImageVersion;
-	uint16_t   MajorSubsystemVersion;
-	uint16_t   MinorSubsystemVersion;
-	uint32_t   Win32VersionValue;
-	uint32_t   SizeOfImage;
-	uint32_t   SizeOfHeaders;
-	uint32_t   CheckSum;
-	uint16_t   Subsystem;
-	uint16_t   DllCharacteristics;
-	uint32_t   SizeOfStackReserve;
-	uint32_t   SizeOfStackCommit;
-	uint32_t   SizeOfHeapReserve;
-	uint32_t   SizeOfHeapCommit;
-	uint32_t   LoaderFlags;
-	uint32_t   NumberOfRvaAndSizes;
-	IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
-};
-
-struct IMAGE_NT_HEADERS
-{
-	uint32_t Signature;
-	IMAGE_FILE_HEADER FileHeader;
-	IMAGE_OPTIONAL_HEADER32 OptionalHeader;
-};
-
-#define IMAGE_SIZEOF_SHORT_NAME              8
-
-struct IMAGE_SECTION_HEADER
-{
-	uint8_t    Name[IMAGE_SIZEOF_SHORT_NAME];
-	union {
-		uint32_t   PhysicalAddress;
-		uint32_t   VirtualSize;
-	} Misc;
-	uint32_t   VirtualAddress;
-	uint32_t   SizeOfRawData;
-	uint32_t   PointerToRawData;
-	uint32_t   PointerToRelocations;
-	uint32_t   PointerToLinenumbers;
-	uint16_t   NumberOfRelocations;
-	uint16_t   NumberOfLinenumbers;
-	uint32_t   Characteristics;
-};
-
-struct IMAGE_COR20_HEADER
-{
-	// Header versioning
-	uint32_t                   cb;
-	uint16_t                   MajorRuntimeVersion;
-	uint16_t                   MinorRuntimeVersion;
-
-	// Symbol table and startup information
-	IMAGE_DATA_DIRECTORY    MetaData;
-	uint32_t                   Flags;
-
-	// The main program if it is an EXE (not used if a DLL?)
-	// If COMIMAGE_FLAGS_NATIVE_ENTRYPOINT is not set, EntryPointToken represents a managed entrypoint.
-	// If COMIMAGE_FLAGS_NATIVE_ENTRYPOINT is set, EntryPointRVA represents an RVA to a native entrypoint
-	// (depricated for DLLs, use modules constructors intead). 
-	union {
-		uint32_t               EntryPointToken;
-		uint32_t               EntryPointRVA;
-	};
-
-	// This is the blob of managed resources. Fetched using code:AssemblyNative.GetResource and
-	// code:PEFile.GetResource and accessible from managed code from
-	// System.Assembly.GetManifestResourceStream.  The meta data has a table that maps names to offsets into
-	// this blob, so logically the blob is a set of resources. 
-	IMAGE_DATA_DIRECTORY    Resources;
-	// IL assemblies can be signed with a public-private key to validate who created it.  The signature goes
-	// here if this feature is used. 
-	IMAGE_DATA_DIRECTORY    StrongNameSignature;
-
-	IMAGE_DATA_DIRECTORY    CodeManagerTable;			// Depricated, not used 
-														// Used for manged codee that has unmaanaged code inside it (or exports methods as unmanaged entry points)
-	IMAGE_DATA_DIRECTORY    VTableFixups;
-	IMAGE_DATA_DIRECTORY    ExportAddressTableJumps;
-
-	// null for ordinary IL images.  NGEN images it points at a code:CORCOMPILE_HEADER structure
-	IMAGE_DATA_DIRECTORY    ManagedNativeHeader;
-};
-
-enum ReplacesCorHdrNumericDefines
-{
-	// COM+ Header entry point flags.
-	COMIMAGE_FLAGS_ILONLY = 0x00000001,
-	COMIMAGE_FLAGS_32BITREQUIRED = 0x00000002,    // *** Do not manipulate this bit directly (see notes above)
-	COMIMAGE_FLAGS_IL_LIBRARY = 0x00000004,
-	COMIMAGE_FLAGS_STRONGNAMESIGNED = 0x00000008,
-	COMIMAGE_FLAGS_NATIVE_ENTRYPOINT = 0x00000010,
-	COMIMAGE_FLAGS_TRACKDEBUGDATA = 0x00010000,
-	COMIMAGE_FLAGS_32BITPREFERRED = 0x00020000
-};
-
-#pragma pack(pop)
-
-static const IMAGE_SECTION_HEADER& FindSection(const char* name, const IMAGE_SECTION_HEADER* begin, const IMAGE_SECTION_HEADER* end)
-{
-	for (auto section = begin; section != end; section++)
-	{
-		if (!strcmp(name, reinterpret_cast<const char*>(section->Name)))
-			return *section;
-	}
-
-	THROW_IF_NOT(false, BadImageException, "No desired section found");
-}
-
-AssemblyFile::AssemblyFile(std::shared_ptr<const uint8_t[]> data, size_t size)
-	:fileData_(std::move(data))
-{
-	auto base = fileData_.get();
-	auto dosHeader = reinterpret_cast<const IMAGE_DOS_HEADER*>(base);
-	THROW_IF_NOT(dosHeader->e_magic == IMAGE_DOS_SIGNATURE, BadImageException, "Invalid dos signature");
-	auto ntHeader = reinterpret_cast<const IMAGE_NT_HEADERS*>(base + dosHeader->e_lfanew);
-	THROW_IF_NOT(ntHeader->Signature == IMAGE_NT_SIGNATURE, BadImageException, "Invalid pe signature");
-	auto& comDataDir = ntHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR];
-
-	auto firstSection = reinterpret_cast<const IMAGE_SECTION_HEADER*>(uintptr_t(&ntHeader->OptionalHeader) + ntHeader->FileHeader.SizeOfOptionalHeader);
-	auto& textSection = FindSection(".text", firstSection, firstSection + ntHeader->FileHeader.NumberOfSections);
-	textBase_ = base + textSection.PointerToRawData;
-	textRVA_ = textSection.VirtualAddress;
-
-	auto corHeader = reinterpret_cast<const IMAGE_COR20_HEADER*>(GetDataByRVA(comDataDir.VirtualAddress));
-	THROW_IF_NOT(corHeader->Flags == COMIMAGE_FLAGS_ILONLY, BadImageException, "Only support IL Only");
-	metadataRVA_ = corHeader->MetaData.VirtualAddress;
-}
-
-const uint8_t* AssemblyFile::GetDataByRVA(uintptr_t rva) const noexcept
-{
-	return textBase_ + (rva - textRVA_);
-}

src/natsuclr/loader/AssemblyLoader.cpp

@@ -1,323 +0,0 @@
-//
-// Natsu CLR Loader
-//
-#include <cassert>
-#include <loader/AssemblyLoader.hpp>
-#include <loader/Layout.hpp>
-#include <md/Signature.hpp>
-#include <utils.hpp>
-#include <vm/ECall.hpp>
-
-using namespace clr::loader;
-using namespace clr::metadata;
-using namespace clr::vm;
-
-AssemblyLoader::AssemblyLoader(std::shared_ptr<AssemblyFile> assemblyFile)
-    : mdImporter_(assemblyFile), assemblyFile_(assemblyFile)
-{
-}
-
-void AssemblyLoader::Load()
-{
-    auto typeDefs = mdImporter_.GetTables().GetRowsCount(mdt_TypeDef);
-    eeClasses_.resize(typeDefs);
-    auto fields = mdImporter_.GetTables().GetRowsCount(mdt_Field);
-    fieldDescs_.resize(fields);
-    auto methodDefs = mdImporter_.GetTables().GetRowsCount(mdt_MethodDef);
-    methodDescs_.resize(methodDefs);
-
-    // Type
-    for (uint32_t i = 0; i < typeDefs; i++)
-        LoadTypeDef(i);
-
-    // GenericParam
-    auto genericParams = mdImporter_.GetTables().GetRowsCount(mdt_GenericParam);
-    for (uint32_t i = 0; i < genericParams; i++)
-        LoadGenericParam(i);
-
-    // Field
-    for (uint32_t i = 0; i < fields; i++)
-        LoadField(i);
-
-    for (uint32_t i = 0; i < typeDefs; i++)
-        LoadTypeInstanceField(i);
-    for (uint32_t i = 0; i < typeDefs; i++)
-        LoadTypeStaticField(i);
-
-    // Method
-    for (uint32_t i = 0; i < methodDefs; i++)
-        LoadMethodDef(i);
-}
-
-void AssemblyLoader::LoadTypeDef(uint32_t index)
-{
-    auto& tables = mdImporter_.GetTables();
-    auto& strings = mdImporter_.GetStrings();
-
-    auto&& eeClass = eeClasses_[index];
-
-    eeClass.MDImporter = &mdImporter_;
-
-    auto typeDef = tables.GetTypeDef({ index + 1 });
-    eeClass.TypeName = strings.GetString(typeDef.TypeName);
-    eeClass.TypeNamespace = strings.GetString(typeDef.TypeNamespace);
-
-    auto hasNextType = index + 1 < tables.GetRowsCount(mdt_TypeDef);
-
-    if (typeDef.MethodList)
-    {
-        eeClass.FirstMethod = methodDescs_.data() + typeDef.MethodList() - 1;
-        if (hasNextType)
-            eeClass.LastMethod = methodDescs_.data() + tables.GetTypeDef({ index + 2 }).MethodList() - 1;
-        else
-            eeClass.LastMethod = methodDescs_.data() + methodDescs_.size();
-
-        for (auto method = eeClass.FirstMethod; method != eeClass.LastMethod; method++)
-            method->Class = &eeClass;
-    }
-
-    if (typeDef.FieldList)
-    {
-        eeClass.FirstField = fieldDescs_.data() + typeDef.FieldList() - 1;
-        if (hasNextType)
-            eeClass.LastField = fieldDescs_.data() + tables.GetTypeDef({ index + 2 }).FieldList() - 1;
-        else
-            eeClass.LastField = fieldDescs_.data() + fieldDescs_.size();
-
-        for (auto field = eeClass.FirstField; field != eeClass.LastField; field++)
-            field->Class = &eeClass;
-    }
-
-    if (typeDef.Extends)
-    {
-        assert(typeDef.Extends.GetType() == mdt_TypeDef);
-        eeClass.Parent = &GetClass(typeDef.Extends.As<mdt_TypeDef>());
-    }
-}
-
-void AssemblyLoader::LoadMethodDef(uint32_t index)
-{
-    auto& tables = mdImporter_.GetTables();
-    auto& strings = mdImporter_.GetStrings();
-
-    auto&& method = methodDescs_[index];
-
-    auto methodDef = tables.GetMethodDef({ index + 1 });
-    method.Name = strings.GetString(methodDef.Name);
-
-    if ((methodDef.ImplFlags & MethodImplAttributes::InternalCall) == MethodImplAttributes::InternalCall)
-    {
-        method.IsECall = true;
-
-        auto& ecall = FindECall(method);
-        method.ECall.EntryPoint = ecall.EntryPoint;
-        method.ECall.Call = ecall.Call;
-    }
-    else if ((methodDef.Flags & MethodAttributes::Abstract) == MethodAttributes::Abstract)
-    {
-    }
-    else
-    {
-        method.IsECall = false;
-        auto headerOffset = assemblyFile_->GetDataByRVA(methodDef.RVA);
-        BinaryReader br((uintptr_t)headerOffset);
-        {
-            enum
-            {
-                CorILMethod_TinyFormat = 0x2,
-                CorILMethod_FatFormat = 0x3,
-                CorILMethod_FormatMask = 0x3
-            };
-
-            auto flag = br.Read<uint8_t>();
-            auto format = flag & CorILMethod_FormatMask;
-            size_t bodyLength;
-            if (format == CorILMethod_TinyFormat)
-            {
-                bodyLength = flag >> 2;
-
-                method.MaxStack = 8;
-                method.BodyBegin = headerOffset + 1;
-            }
-            else if (format == CorILMethod_FatFormat)
-            {
-                uint16_t fatFloags = (br.Read<uint8_t>() << 8) | flag;
-                auto headerSize = (fatFloags >> 12) * 4;
-                method.MaxStack = br.Read<uint16_t>();
-                bodyLength = br.Read<uint32_t>();
-                auto localVarSigToken = br.Read<mdToken>();
-
-                method.BodyBegin = headerOffset + headerSize;
-
-                if (localVarSigToken)
-                {
-                    assert(localVarSigToken.GetType() == mdt_StandAloneSig);
-                    auto row = mdImporter_.GetTables().GetStandAloneSig(localVarSigToken.As<mdt_StandAloneSig>());
-                    Signature sig(mdImporter_.GetBlobs().GetBlob(row.Signature));
-                    auto localVarParser = sig.CreateParser();
-                    LocalVarSigVisitor visitor;
-                    visitor.AssemblyLoader = this;
-                    visitor.Parse(localVarParser);
-
-                    method.LocalVarSize = (uint32_t)LayoutVars(this, visitor.LocalVarDescs.get(), visitor.LocalVarCount);
-                    method.LocalVarCount = visitor.LocalVarCount;
-                    method.LocalVarDescs = std::move(visitor.LocalVarDescs);
-                }
-            }
-            else
-            {
-                THROW_ALWAYS(BadImageException, "Invalid method header.");
-            }
-
-            method.BodyEnd = method.BodyBegin + bodyLength;
-        }
-    }
-
-    Signature sig(mdImporter_.GetBlobs().GetBlob(methodDef.Signature));
-    auto methodParser = sig.CreateParser();
-    MethodSigVisitor visitor;
-    visitor.AssemblyLoader = this;
-    visitor.Class = method.Class;
-    visitor.Parse(methodParser);
-
-    LayoutVars(this, visitor.ParamDescs.get(), visitor.ParamCount);
-    method.ParamCount = visitor.ParamCount;
-    method.ParamDescs = std::move(visitor.ParamDescs);
-
-    method.RetDesc = visitor.RetDesc.Type;
-}
-
-void AssemblyLoader::LoadField(uint32_t index)
-{
-    auto& tables = mdImporter_.GetTables();
-    auto& strings = mdImporter_.GetStrings();
-
-    auto& fieldDesc = fieldDescs_[index];
-    auto field = tables.GetField({ index + 1 });
-    fieldDesc.Ridx = { index + 1 };
-    fieldDesc.Name = strings.GetString(field.Name);
-    fieldDesc.Flags = field.Flags;
-
-    Signature sig(mdImporter_.GetBlobs().GetBlob(field.Signature));
-    auto sigParser = sig.CreateParser();
-    FieldSigVisitor visitor;
-    visitor.AssemblyLoader = this;
-    visitor.Parse(sigParser);
-    fieldDesc.Var = visitor.FieldVarDesc;
-}
-
-void AssemblyLoader::LoadTypeInstanceField(EEClass& eeClass)
-{
-    auto& tables = mdImporter_.GetTables();
-    auto& strings = mdImporter_.GetStrings();
-
-    if (eeClass.LoadLevel >= clsLoad_InstanceFields)
-        return;
-
-    if (eeClass.Parent && eeClass.Parent->LoadLevel < clsLoad_InstanceFields)
-        LoadTypeInstanceField(*eeClass.Parent);
-
-    auto parentSize = eeClass.Parent ? eeClass.Parent->InstanceSize : 0;
-    size_t offset = parentSize;
-    bool hasMyField = false;
-
-    for (auto fieldDesc = eeClass.FirstField; fieldDesc != eeClass.LastField; ++fieldDesc)
-    {
-        if ((fieldDesc->Flags & FieldAttributes::Static) != FieldAttributes::Static)
-        {
-            hasMyField = true;
-
-            auto& varDesc = fieldDesc->Var;
-            offset = align(offset, varDesc.Type.GetAlign());
-            auto size = varDesc.Type.GetStackSize();
-            varDesc.Offset = uint32_t(offset);
-            offset += size;
-        }
-    }
-
-    if (eeClass.Parent)
-        eeClass.Align = eeClass.Parent->Align;
-    else
-        eeClass.Align = hasMyField ? (uint32_t)eeClass.FirstField->Var.Type.GetAlign() : 1;
-
-    eeClass.InstanceSize = (uint32_t)offset;
-    eeClass.LoadLevel = clsLoad_InstanceFields;
-}
-
-void AssemblyLoader::LoadTypeInstanceField(uint32_t index)
-{
-    LoadTypeInstanceField(eeClasses_[index]);
-}
-
-void AssemblyLoader::LoadTypeStaticField(uint32_t index)
-{
-    auto& tables = mdImporter_.GetTables();
-    auto& strings = mdImporter_.GetStrings();
-    auto& eeClass = eeClasses_[index];
-
-    if (eeClass.LoadLevel >= clsLoad_StaticFields)
-        return;
-
-    // Static & not literal field
-    {
-        size_t offset = 0;
-        for (auto fieldDesc = eeClass.FirstField; fieldDesc != eeClass.LastField; ++fieldDesc)
-        {
-            auto flag = fieldDesc->Flags;
-            if ((flag & FieldAttributes::Static) == FieldAttributes::Static && (flag & FieldAttributes::Literal) != FieldAttributes::Literal)
-            {
-                auto& varDesc = fieldDesc->Var;
-                offset = align(offset, varDesc.Type.GetAlign());
-                auto size = varDesc.Type.GetStackSize();
-                varDesc.Offset = uint32_t(offset);
-                offset += size;
-            }
-        }
-
-        if (offset)
-            eeClass.StaticFields = std::make_unique<uint8_t[]>(offset);
-    }
-
-    eeClass.LoadLevel = clsLoad_StaticFields;
-}
-
-void AssemblyLoader::LoadGenericParam(uint32_t index)
-{
-    auto& tables = mdImporter_.GetTables();
-    auto& strings = mdImporter_.GetStrings();
-    auto row = tables.GetGenericParam({ index + 1 });
-    auto owner = row.Owner;
-
-    GenericDesc* desc;
-    if (owner.GetType() == mdt_TypeDef)
-    {
-        auto& type = GetClass(owner.As<mdt_TypeDef>());
-        desc = &type.GenericParams.emplace_back();
-    }
-    else
-    {
-        auto& method = GetMethod(owner.As<mdt_MethodDef>());
-        desc = &method.GenericParams.emplace_back();
-    }
-
-    desc->Name = strings.GetString(row.Name);
-    desc->Number = row.Number;
-}
-
-MethodDesc& AssemblyLoader::GetMethod(Ridx<mdt_MethodDef> method)
-{
-    assert(method);
-    return methodDescs_[method() - 1];
-}
-
-EEClass& AssemblyLoader::GetClass(Ridx<mdt_TypeDef> type)
-{
-    assert(type);
-    return eeClasses_[type() - 1];
-}
-
-FieldDesc& AssemblyLoader::GetField(Ridx<mdt_Field> field)
-{
-    assert(field);
-    return fieldDescs_[field() - 1];
-}

src/natsuclr/loader/Layout.cpp

@@ -1,123 +0,0 @@
-//
-// Natsu CLR Loader
-//
-#include <cassert>
-#include <utils.hpp>
-#include <loader/AssemblyLoader.hpp>
-#include <loader/Layout.hpp>
-#include <md/Signature.hpp>
-
-using namespace clr::loader;
-using namespace clr::metadata;
-using namespace clr::vm;
-
-void MethodSigVisitor::VisitBeginMethod(uint8_t flag)
-{
-    flag_ = flag;
-    ParamCount = (flag_ & SIG_HASTHIS) ? 1 : 0;
-}
-
-void MethodSigVisitor::VisitBeginRetType()
-{
-    cntVar_ = &RetDesc;
-}
-
-void MethodSigVisitor::VisitBeginParam()
-{
-    if (cntParam_ == -1)
-        cntVar_ = (flag_ & SIG_HASTHIS) ? &ParamDescs[1] : &ParamDescs[0];
-    else
-        cntVar_++;
-    cntParam_++;
-
-    cntVar_->Type.Flags |= tda_Normal;
-}
-
-void MethodSigVisitor::VisitParamCount(uint32_t count)
-{
-    ParamCount = (flag_ & SIG_HASTHIS) ? count + 1 : count;
-    ParamDescs = std::make_unique<VarDesc[]>(ParamCount);
-
-    if (flag_ & SIG_HASTHIS)
-        ParamDescs[0].Type = { tda_Normal, ELEMENT_TYPE_CLASS, 0, Class };
-}
-
-void MethodSigVisitor::VisitBeginType(CorElementType elementType)
-{
-    if (elementType == ELEMENT_TYPE_BYREF)
-        cntVar_->Type.Flags |= tda_ByRef;
-    else
-        cntVar_->Type.Type = elementType;
-}
-
-void MethodSigVisitor::VisitTypeGenericParamNumber(uint32_t number)
-{
-    cntVar_->Type.Flags |= tda_Generic;
-    cntVar_->Type.GenericParam = &Class->GenericParams[number];
-}
-
-void MethodSigVisitor::VisitTypeDefOrRefEncoded(CodedRidx<crid_TypeDefOrRef> cridx)
-{
-    assert(cridx.GetType() == mdt_TypeDef);
-    auto classId = cridx.As<mdt_TypeDef>();
-    cntVar_->Type.Class = &AssemblyLoader->GetClasses()[classId];
-}
-
-void LocalVarSigVisitor::VisitLocalVarCount(uint32_t count)
-{
-    LocalVarCount = count;
-    LocalVarDescs = std::make_unique<VarDesc[]>(count);
-}
-
-void LocalVarSigVisitor::VisitBeginLocalVar()
-{
-    if (cntVar_)
-        cntVar_++;
-    else
-        cntVar_ = LocalVarDescs.get();
-}
-
-void LocalVarSigVisitor::VisitBeginType(CorElementType elementType)
-{
-    if (elementType == ELEMENT_TYPE_BYREF)
-        cntVar_->Type.Flags |= tda_ByRef;
-    else
-        cntVar_->Type.Type = elementType;
-}
-
-void LocalVarSigVisitor::VisitTypeDefOrRefEncoded(CodedRidx<crid_TypeDefOrRef> cridx)
-{
-    assert(cridx.GetType() == mdt_TypeDef);
-    auto classId = cridx.As<mdt_TypeDef>();
-    cntVar_->Type.Class = &AssemblyLoader->GetClasses()[classId];
-}
-
-void FieldSigVisitor::VisitBeginType(CorElementType elementType)
-{
-    if (elementType == ELEMENT_TYPE_BYREF)
-        FieldVarDesc.Type.Flags |= tda_ByRef;
-    else
-        FieldVarDesc.Type.Type = elementType;
-}
-
-void FieldSigVisitor::VisitTypeDefOrRefEncoded(CodedRidx<crid_TypeDefOrRef> cridx)
-{
-    assert(cridx.GetType() == mdt_TypeDef);
-    auto classId = cridx.As<mdt_TypeDef>();
-    FieldVarDesc.Type.Class = &AssemblyLoader->GetClasses()[classId];
-}
-
-size_t clr::loader::LayoutVars(AssemblyLoader* assemblyLoader, VarDesc* descs, size_t count)
-{
-    size_t offset = 0;
-    for (size_t i = 0; i < count; i++)
-    {
-        auto& desc = descs[i];
-        offset = align(offset, desc.Type.GetAlign());
-        auto size = desc.Type.GetStackSize();
-        desc.Offset = uint32_t(offset);
-        offset += size;
-    }
-
-    return offset;
-}

src/natsuclr/md/MDImporter.cpp

@@ -1,565 +0,0 @@
-//
-// Natsu CLR Metadata
-//
-#include <algorithm>
-#include <bitset>
-#include <cassert>
-#include <limits>
-#include <md/MDImporter.hpp>
-#include <stdexcept>
-#include <utils.hpp>
-
-using namespace clr::loader;
-using namespace clr::metadata;
-
-#pragma pack(push, 1)
-
-#define STORAGE_MAGIC_SIG 0x424A5342 // BSJB
-
-struct MetadataSignature
-{
-    uint32_t Signature;
-    uint16_t MarjorVersion;
-    uint16_t MinorVersion;
-    uint32_t ExtraData;
-    uint32_t VersionStringLength;
-    char VersionString[0];
-};
-
-struct MetadataHeader
-{
-    uint8_t Flags;
-    uint8_t Pad0;
-    uint16_t NumberOfStreams;
-};
-
-#define MAXSTREAMNAME 32
-
-struct StreamHeader
-{
-    uint32_t Offset;
-    uint32_t Size;
-    char Name[MAXSTREAMNAME];
-};
-
-struct MetadataStreamHeader
-{
-    uint32_t Reserved0;
-    uint8_t MajorVersion;
-    uint8_t MinorVersion;
-    uint8_t HeapSizes;
-    uint8_t Reserved1;
-    uint64_t Valid;
-    uint64_t Sorted;
-    uint32_t Rows[0];
-};
-
-#pragma pack(pop)
-
-#define INIT_STREAM(field, name) (!strncmp(streamBegin->Name, name, MAXSTREAMNAME)) field.Initialize(uintptr_t(metaSig) + streamBegin->Offset)
-
-MDImporter::MDImporter(std::shared_ptr<AssemblyFile> assemblyFile)
-    : assemblyFile_(std::move(assemblyFile))
-{
-    auto metaSig = reinterpret_cast<const MetadataSignature*>(assemblyFile_->GetDataByRVA(assemblyFile_->GetMetadataRVA()));
-    THROW_IF_NOT(metaSig->Signature == STORAGE_MAGIC_SIG, BadMetadataException, "Invalid metadata signature");
-    auto metaHeader = reinterpret_cast<const MetadataHeader*>(uintptr_t(metaSig) + sizeof(MetadataSignature) + metaSig->VersionStringLength);
-
-    auto streamBegin = reinterpret_cast<const StreamHeader*>(uintptr_t(metaHeader) + sizeof(MetadataHeader));
-    for (size_t i = 0; i < metaHeader->NumberOfStreams; i++)
-    {
-        if
-            INIT_STREAM(metaStream_, "#~");
-        else if
-            INIT_STREAM(stringsStream_, "#Strings");
-        else if
-            INIT_STREAM(usStream_, "#US");
-        else if
-            INIT_STREAM(guidStream_, "#GUID");
-        else if
-            INIT_STREAM(blobStream_, "#Blob");
-        else
-            THROW_IF_NOT(false, BadMetadataException, "Unrecognized stream name");
-        auto headerSize = align(8 + strlen(streamBegin->Name) + 1, 4);
-        streamBegin = reinterpret_cast<const StreamHeader*>(uintptr_t(streamBegin) + headerSize);
-    }
-}
-
-#define INIT_TABLE_COUNT(type) \
-    if (valid[mdt_##type])     \
-    tables_[mdt_##type].reset(new type##Table(*rows++))
-#define INIT_TABLE(type)   \
-    if (valid[mdt_##type]) \
-    tables_[mdt_##type]->Initialize(tableContent, *this)
-
-void MetadataStream::Initialize(uintptr_t content)
-{
-    auto header = reinterpret_cast<const MetadataStreamHeader*>(content);
-    heapSizes_ = header->HeapSizes;
-    THROW_IF_NOT(heapSizes_ == 0, BadMetadataException, "Only support tiny heaps");
-
-    const std::bitset<64> valid(header->Valid);
-
-    assert(valid.count() == 16);
-
-    auto rows = header->Rows;
-    INIT_TABLE_COUNT(Module);
-    INIT_TABLE_COUNT(TypeDef);
-    INIT_TABLE_COUNT(Field);
-    INIT_TABLE_COUNT(MethodDef);
-    INIT_TABLE_COUNT(Param);
-    INIT_TABLE_COUNT(MemberRef);
-    INIT_TABLE_COUNT(Constant);
-    INIT_TABLE_COUNT(CustomAttribute);
-    INIT_TABLE_COUNT(ClassLayout);
-    INIT_TABLE_COUNT(StandAloneSig);
-    INIT_TABLE_COUNT(PropertyMap);
-    INIT_TABLE_COUNT(Property);
-    INIT_TABLE_COUNT(MethodSemantics);
-    INIT_TABLE_COUNT(TypeSpec);
-    INIT_TABLE_COUNT(Assembly);
-    INIT_TABLE_COUNT(GenericParam);
-
-    auto tableContent = uintptr_t(header->Rows) + valid.count() * sizeof(uint32_t);
-    INIT_TABLE(Module);
-    INIT_TABLE(TypeDef);
-    INIT_TABLE(Field);
-    INIT_TABLE(MethodDef);
-    INIT_TABLE(Param);
-    INIT_TABLE(MemberRef);
-    INIT_TABLE(Constant);
-    INIT_TABLE(CustomAttribute);
-    INIT_TABLE(ClassLayout);
-    INIT_TABLE(StandAloneSig);
-    INIT_TABLE(PropertyMap);
-    INIT_TABLE(Property);
-    INIT_TABLE(MethodSemantics);
-    INIT_TABLE(TypeSpec);
-    INIT_TABLE(Assembly);
-    INIT_TABLE(GenericParam);
-}
-
-size_t MetadataStream::GetSidxSize(StreamType stream) const noexcept
-{
-    switch (stream)
-    {
-    case stm_String:
-    case stm_GUID:
-    case stm_Blob:
-        return (heapSizes_ & stream) ? sizeof(uint32_t) : sizeof(uint16_t);
-    default:
-        assert(!"invalid stream type");
-        return 0;
-    }
-}
-
-size_t MetadataStream::GetRowsCount(MetadataTables table) const noexcept
-{
-    auto pTable = tables_[table].get();
-    return pTable ? pTable->GetCount() : 0;
-}
-
-size_t MetadataStream::GetRidxSize(MetadataTables table) const noexcept
-{
-    return GetRowsCount(table) > std::numeric_limits<uint16_t>::max() ? 4 : 2;
-}
-
-#define IMPL_CODED_RIDX_SIZE(ridxType) \
-    case ridxType:                     \
-        return GetMaxRowsCount([this](auto t) { return GetRowsCount(t); }, CodedRidx<ridxType>::PackedTypes()) >= CodedRidx<ridxType>::SizeThreshold ? 4 : 2;
-
-template <class TCallable, MetadataTables... Types>
-size_t GetMaxRowsCount(TCallable&& callable, impl::value_sequence<MetadataTables, Types...>) noexcept
-{
-    return std::max({ callable(Types)... });
-}
-
-size_t MetadataStream::GetCodedRidxSize(CodedRowIndex ridxType) const noexcept
-{
-    switch (ridxType)
-    {
-        IMPL_CODED_RIDX_SIZE(crid_TypeDefOrRef);
-        IMPL_CODED_RIDX_SIZE(crid_HasConstant);
-        IMPL_CODED_RIDX_SIZE(crid_HasCustomAttribute);
-        //IMPL_CODED_RIDX_SIZE(crid_HasFieldMarshall);
-        //IMPL_CODED_RIDX_SIZE(crid_HasDeclSecurity);
-        IMPL_CODED_RIDX_SIZE(crid_MemberRefParent);
-        IMPL_CODED_RIDX_SIZE(crid_HasSemantics);
-        //IMPL_CODED_RIDX_SIZE(crid_MethodDefOrRef);
-        //IMPL_CODED_RIDX_SIZE(crid_MemberForwarded);
-        //IMPL_CODED_RIDX_SIZE(crid_Implementation);
-        IMPL_CODED_RIDX_SIZE(crid_CustomAttributeType);
-        //IMPL_CODED_RIDX_SIZE(crid_ResolutionScope);
-        IMPL_CODED_RIDX_SIZE(crid_TypeOrMethodDef);
-    default:
-        assert(!"invalid coded row index type");
-        return 0;
-    }
-}
-
-#define IMPL_GET_ROW1(type)                                                          \
-    typename type##Table::Row MetadataStream::Get##type(Ridx<mdt_##type> ridx) const \
-    {                                                                                \
-        auto table = tables_[mdt_##type].get();                                      \
-        THROW_IF_NOT(ridx&& table, std::out_of_range, "row id out of range");        \
-        return static_cast<const type##Table*>(table)->GetRow(ridx, *this);          \
-    }
-
-IMPL_GET_ROW1(TypeDef);
-IMPL_GET_ROW1(MethodDef);
-IMPL_GET_ROW1(Field);
-IMPL_GET_ROW1(Param);
-IMPL_GET_ROW1(MemberRef);
-IMPL_GET_ROW1(Constant);
-IMPL_GET_ROW1(CustomAttribute);
-IMPL_GET_ROW1(ClassLayout);
-IMPL_GET_ROW1(StandAloneSig);
-IMPL_GET_ROW1(PropertyMap);
-IMPL_GET_ROW1(Property);
-IMPL_GET_ROW1(MethodSemantics);
-IMPL_GET_ROW1(TypeSpec);
-IMPL_GET_ROW1(Assembly);
-IMPL_GET_ROW1(GenericParam);
-
-MetadataTable::MetadataTable(size_t count)
-    : count_(count)
-{
-}
-
-void MetadataTable::Initialize(uintptr_t& content, MetadataStream& context)
-{
-    base_ = content;
-    rowSize_ = GetRowSize(context);
-    content += rowSize_ * count_;
-}
-
-uintptr_t MetadataTable::GetRowBase(size_t index) const noexcept
-{
-    return base_ + (index - 1) * rowSize_;
-}
-
-// Assembly
-
-size_t AssemblyTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return 4 + 2 * 4 + 4 + context.GetSidxSize(stm_Blob) + context.GetSidxSize(stm_String) * 2;
-}
-
-auto AssemblyTable::GetRow(Ridx<mdt_Assembly> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<AssemblyHashAlgorithm>(),
-        br.Read<uint16_t>(),
-        br.Read<uint16_t>(),
-        br.Read<uint16_t>(),
-        br.Read<uint16_t>(),
-        br.Read<AssemblyFlags>(),
-        br.Read<Sidx<stm_Blob>>(context.GetSidxSize(stm_Blob)),
-        br.Read<Sidx<stm_String>>(context.GetSidxSize(stm_String)),
-        br.Read<Sidx<stm_String>>(context.GetSidxSize(stm_String))
-    };
-}
-
-// ClassLayout
-
-size_t ClassLayoutTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return 2 + 4 + context.GetRidxSize(mdt_TypeDef);
-}
-
-auto ClassLayoutTable::GetRow(Ridx<mdt_ClassLayout> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<uint16_t>(),
-        br.Read<uint32_t>(),
-        br.Read<Ridx<mdt_TypeDef>>(context.GetRidxSize(mdt_TypeDef)),
-    };
-}
-
-// Constant
-
-size_t ConstantTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return 1 + 1 + context.GetCodedRidxSize(crid_HasConstant) + context.GetSidxSize(stm_Blob);
-}
-
-auto ConstantTable::GetRow(Ridx<mdt_Constant> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<CorElementType>(),
-        0,
-        br.Read<CodedRidx<crid_HasConstant>>(context.GetCodedRidxSize(crid_HasConstant)),
-        br.Read<Sidx<stm_Blob>>(context.GetSidxSize(stm_Blob))
-    };
-}
-
-// CustomAttribute
-
-size_t CustomAttributeTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return context.GetCodedRidxSize(crid_HasCustomAttribute) + context.GetCodedRidxSize(crid_CustomAttributeType) + context.GetSidxSize(stm_Blob);
-}
-
-auto CustomAttributeTable::GetRow(Ridx<mdt_CustomAttribute> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<CodedRidx<crid_HasCustomAttribute>>(context.GetCodedRidxSize(crid_HasCustomAttribute)),
-        br.Read<CodedRidx<crid_HasConstant>>(context.GetCodedRidxSize(crid_HasConstant)),
-        br.Read<Sidx<stm_Blob>>(context.GetSidxSize(stm_Blob))
-    };
-}
-
-// Field
-
-size_t FieldTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return 2 + context.GetSidxSize(stm_String) + context.GetSidxSize(stm_Blob);
-}
-
-auto FieldTable::GetRow(Ridx<mdt_Field> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<FieldAttributes>(),
-        br.Read<Sidx<stm_String>>(context.GetSidxSize(stm_String)),
-        br.Read<Sidx<stm_Blob>>(context.GetSidxSize(stm_Blob))
-    };
-}
-
-// GenericParam
-
-size_t GenericParamTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return 4 + context.GetCodedRidxSize(crid_TypeOrMethodDef) + context.GetSidxSize(stm_String);
-}
-
-auto GenericParamTable::GetRow(Ridx<mdt_GenericParam> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<uint16_t>(),
-        br.Read<GenericParamAttributes>(),
-        br.Read<CodedRidx<crid_TypeOrMethodDef>>(context.GetCodedRidxSize(crid_TypeOrMethodDef)),
-        br.Read<Sidx<stm_String>>(context.GetSidxSize(stm_String))
-    };
-}
-
-// MemberRef
-
-size_t MemberRefTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return context.GetCodedRidxSize(crid_MemberRefParent) + context.GetSidxSize(stm_String) + context.GetSidxSize(stm_Blob);
-}
-
-auto MemberRefTable::GetRow(Ridx<mdt_MemberRef> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<CodedRidx<crid_MemberRefParent>>(context.GetCodedRidxSize(crid_MemberRefParent)),
-        br.Read<Sidx<stm_String>>(context.GetSidxSize(stm_String)),
-        br.Read<Sidx<stm_Blob>>(context.GetSidxSize(stm_Blob))
-    };
-}
-
-// MethodDef
-
-size_t MethodDefTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return 4 + 2 + 2 + context.GetSidxSize(stm_String) + context.GetSidxSize(stm_Blob) + context.GetRidxSize(mdt_Param);
-}
-
-auto MethodDefTable::GetRow(Ridx<mdt_MethodDef> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<uint32_t>(),
-        br.Read<MethodImplAttributes>(),
-        br.Read<MethodAttributes>(),
-        br.Read<Sidx<stm_String>>(context.GetSidxSize(stm_String)),
-        br.Read<Sidx<stm_Blob>>(context.GetSidxSize(stm_Blob)),
-        br.Read<Ridx<mdt_Param>>(context.GetRidxSize(mdt_Param))
-    };
-}
-
-// MethodSemantics
-
-size_t MethodSemanticsTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return 2 + context.GetRidxSize(mdt_MethodDef) + context.GetCodedRidxSize(crid_HasSemantics);
-}
-
-auto MethodSemanticsTable::GetRow(Ridx<mdt_MethodSemantics> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<MethodSemanticsAttributes>(),
-        br.Read<Ridx<mdt_MethodDef>>(context.GetRidxSize(mdt_MethodDef)),
-        br.Read<CodedRidx<crid_HasSemantics>>(context.GetCodedRidxSize(crid_HasSemantics))
-    };
-}
-
-// Module
-
-size_t ModuleTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return 2 + context.GetSidxSize(stm_String) + context.GetSidxSize(stm_GUID) * 3;
-}
-
-// Param
-
-size_t ParamTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return 2 + 2 + context.GetSidxSize(stm_String);
-}
-
-auto ParamTable::GetRow(Ridx<mdt_Param> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<ParamAttributes>(),
-        br.Read<uint16_t>(),
-        br.Read<Sidx<stm_String>>(context.GetSidxSize(stm_String))
-    };
-}
-
-// Property
-
-size_t PropertyTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return 2 + context.GetSidxSize(stm_String) + context.GetSidxSize(stm_Blob);
-}
-
-auto PropertyTable::GetRow(Ridx<mdt_Property> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<PropertyAttributes>(),
-        br.Read<Sidx<stm_String>>(context.GetSidxSize(stm_String)),
-        br.Read<Sidx<stm_Blob>>(context.GetSidxSize(stm_Blob))
-    };
-}
-
-// PropertyMap
-
-size_t PropertyMapTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return context.GetRidxSize(mdt_TypeDef) + context.GetRidxSize(mdt_Property);
-}
-
-auto PropertyMapTable::GetRow(Ridx<mdt_PropertyMap> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<Ridx<mdt_TypeDef>>(context.GetRidxSize(mdt_TypeDef)),
-        br.Read<Ridx<mdt_Property>>(context.GetRidxSize(mdt_Property))
-    };
-}
-
-// StandAloneSig
-
-size_t StandAloneSigTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return context.GetSidxSize(stm_Blob);
-}
-
-auto StandAloneSigTable::GetRow(Ridx<mdt_StandAloneSig> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<Sidx<stm_Blob>>(context.GetSidxSize(stm_Blob))
-    };
-}
-
-// TypeSpec
-
-size_t TypeSpecTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return context.GetSidxSize(stm_Blob);
-}
-
-auto TypeSpecTable::GetRow(Ridx<mdt_TypeSpec> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<Sidx<stm_Blob>>(context.GetSidxSize(stm_Blob))
-    };
-}
-
-// TypeDef
-
-size_t TypeDefTable::GetRowSize(MetadataStream& context) const noexcept
-{
-    return 4 + context.GetSidxSize(stm_String) * 2 + context.GetCodedRidxSize(crid_TypeDefOrRef) + context.GetRidxSize(mdt_Field) + context.GetRidxSize(mdt_MethodDef);
-}
-
-auto TypeDefTable::GetRow(Ridx<mdt_TypeDef> ridx, const MetadataStream& context) const -> Row
-{
-    BinaryReader br(GetRowBase(ridx()));
-    return {
-        br.Read<TypeAttributes>(),
-        br.Read<Sidx<stm_String>>(context.GetSidxSize(stm_String)),
-        br.Read<Sidx<stm_String>>(context.GetSidxSize(stm_String)),
-        br.Read<CodedRidx<crid_TypeDefOrRef>>(context.GetCodedRidxSize(crid_TypeDefOrRef)),
-        br.Read<Ridx<mdt_Field>>(context.GetRidxSize(mdt_Field)),
-        br.Read<Ridx<mdt_MethodDef>>(context.GetRidxSize(mdt_MethodDef))
-    };
-}
-
-void StringsStream::Initialize(uintptr_t content)
-{
-    content_ = reinterpret_cast<const char*>(content);
-}
-
-std::string_view StringsStream::GetString(Sidx<stm_String> sidx) const noexcept
-{
-    return content_ + sidx();
-}
-
-void USStream::Initialize(uintptr_t content)
-{
-    content_ = reinterpret_cast<const char*>(content);
-}
-
-void GUIDStream::Initialize(uintptr_t content)
-{
-    content_ = reinterpret_cast<const char*>(content);
-}
-
-void BlobStream::Initialize(uintptr_t content)
-{
-    content_ = reinterpret_cast<const uint8_t*>(content);
-}
-
-#define BLOB_4_BYTES_MASK uint8_t(0b11000000)
-#define BLOB_2_BYTES_MASK uint8_t(0b10000000)
-#define BLOB_1_BYTES_MASK uint8_t(0b00000000)
-#define BLOB_SIZE_MASK uint8_t(0b11100000)
-
-BlobData BlobStream::GetBlob(Sidx<stm_Blob> sidx) const
-{
-    auto base = content_ + sidx();
-
-    size_t size;
-    auto firstByte = *base++;
-    switch (firstByte & BLOB_SIZE_MASK)
-    {
-    case BLOB_1_BYTES_MASK:
-        size = firstByte & ~BLOB_1_BYTES_MASK;
-        break;
-    case BLOB_2_BYTES_MASK:
-        size = ((firstByte & ~BLOB_2_BYTES_MASK) << 8) + *base++;
-        break;
-    case BLOB_4_BYTES_MASK:
-        size = ((firstByte & ~BLOB_4_BYTES_MASK) << 24) + (*base++ << 16) + (*base++ << 8) + *base++;
-        break;
-    default:
-        THROW_ALWAYS(BadMetadataException, "Invalid blob size");
-        break;
-    }
-
-    return { base, size };
-}

src/natsuclr/md/Signature.cpp

@@ -1,397 +0,0 @@
-//
-// Natsu CLR Metadata
-//
-#include <cassert>
-#include <md/Signature.hpp>
-#include <utils.hpp>
-
-using namespace clr;
-using namespace clr::metadata;
-
-SigParser Signature::CreateParser() const noexcept
-{
-    return { blobData_.Data, blobData_.Length };
-}
-
-uint8_t SigParser::GetByte()
-{
-    auto ptr = base_;
-    SkipBytes(1);
-    return *ptr;
-}
-
-uint8_t SigParser::PeekByte()
-{
-    assert(len_);
-    return *base_;
-}
-
-uint32_t SigParser::GetNumber()
-{
-    auto b0 = GetByte();
-    assert(b0 != 0xFF);
-
-    if ((b0 & 0x80) == 0)
-        return b0;
-
-    auto b1 = GetByte();
-    if ((b0 & 0x40) == 0)
-        return ((b0 & 0x3F) << 8) | b1;
-
-    assert((b0 & 0x20) == 0);
-    return ((b0 & 0x1F) << 24) | (b1 << 16) | (GetByte() << 8) | GetByte();
-}
-
-void SigParser::SkipBytes(size_t len)
-{
-    assert(len <= len_);
-    base_ += len;
-    len_ -= len;
-}
-
-bool SigParser::IsEmpty() const noexcept
-{
-    return len_ == 0;
-}
-
-/*
-
-Sig ::= MethodDefSig | MethodRefSig | StandAloneMethodSig | FieldSig | PropertySig | LocalVarSig
-
-MethodDefSig ::= [[HASTHIS] [EXPLICITTHIS]] (DEFAULT|VARARG|GENERIC GenParamCount) ParamCount RetType Param*
-
-MethodRefSig ::= [[HASTHIS] [EXPLICITTHIS]] VARARG ParamCount RetType Param* [SENTINEL Param+]
-
-StandAloneMethodSig ::=  [[HASTHIS] [EXPLICITTHIS]] (DEFAULT|VARARG|C|STDCALL|THISCALL|FASTCALL)
-ParamCount RetType Param* [SENTINEL Param+]
-
-FieldSig ::= FIELD CustomMod* Type
-
-PropertySig ::= PROPERTY [HASTHIS] ParamCount CustomMod* Type Param*
-
-LocalVarSig ::= LOCAL_SIG Count (TYPEDBYREF | ([CustomMod] [Constraint])* [BYREF] Type)+
-
-
--------------
-
-CustomMod ::= ( CMOD_OPT | CMOD_REQD ) ( TypeDefEncoded | TypeRefEncoded )
-
-Constraint ::= #define ELEMENT_TYPE_PINNED
-
-Param ::= CustomMod* ( TYPEDBYREF | [BYREF] Type )
-
-RetType ::= CustomMod* ( VOID | TYPEDBYREF | [BYREF] Type )
-
-Type ::= ( BOOLEAN | CHAR | I1 | U1 | U2 | U2 | I4 | U4 | I8 | U8 | R4 | R8 | I | U |
-| VALUETYPE TypeDefOrRefEncoded
-| CLASS TypeDefOrRefEncoded
-| STRING
-| OBJECT
-| PTR CustomMod* VOID
-| PTR CustomMod* Type
-| FNPTR MethodDefSig
-| FNPTR MethodRefSig
-| ARRAY Type ArrayShape
-| SZARRAY CustomMod* Type
-| GENERICINST (CLASS | VALUETYPE) TypeDefOrRefEncoded GenArgCount Type*
-| VAR Number
-| MVAR Number
-
-ArrayShape ::= Rank NumSizes Size* NumLoBounds LoBound*
-
-TypeDefOrRefEncoded ::= TypeDefEncoded | TypeRefEncoded
-TypeDefEncoded ::= 32-bit-3-part-encoding-for-typedefs-and-typerefs
-TypeRefEncoded ::= 32-bit-3-part-encoding-for-typedefs-and-typerefs
-
-ParamCount ::= 29-bit-encoded-integer
-GenArgCount ::= 29-bit-encoded-integer
-Count ::= 29-bit-encoded-integer
-Rank ::= 29-bit-encoded-integer
-NumSizes ::= 29-bit-encoded-integer
-Size ::= 29-bit-encoded-integer
-NumLoBounds ::= 29-bit-encoded-integer
-LoBounds ::= 29-bit-encoded-integer
-Number ::= 29-bit-encoded-integer
-
-*/
-
-void SignatureVisitor::Parse(SigParser& parser)
-{
-    auto sigType = parser.GetByte();
-    switch (sigType & 0xF)
-    {
-    case SIG_METHOD_DEFAULT:
-    case SIG_METHOD_C:
-    case SIG_METHOD_STDCALL:
-    case SIG_METHOD_THISCALL:
-    case SIG_METHOD_FASTCALL:
-    case SIG_METHOD_VARARG:
-        ParseMethod(parser, sigType);
-        break;
-    case SIG_FIELD:
-        ParseField(parser, sigType);
-        break;
-    case SIG_LOCAL_SIG:
-        ParseLocals(parser, sigType);
-        break;
-    case SIG_PROPERTY:
-        ParseProperty(parser, sigType);
-        break;
-    default:
-        THROW_ALWAYS(BadMetadataException, "Invalid signature type.");
-        break;
-    }
-}
-
-void SignatureVisitor::ParseMethod(SigParser& parser, uint8_t flag)
-{
-    VisitBeginMethod(flag);
-
-    assert((flag & SIG_GENERIC) == 0);
-    auto paramCount = parser.GetNumber();
-    VisitParamCount(paramCount);
-
-    ParseRetType(parser);
-    for (size_t i = 0; i < paramCount; i++)
-    {
-        auto type = parser.PeekByte();
-        assert(type != ELEMENT_TYPE_SENTINEL);
-        ParseParam(parser);
-    }
-
-    VisitEndMethod();
-}
-
-void SignatureVisitor::ParseField(SigParser& parser, uint8_t flag)
-{
-    VisitBeginField(flag);
-
-    ParseOptionalCustomMods(parser);
-    ParseType(parser);
-
-    VisitEndField();
-}
-
-void SignatureVisitor::VisitBeginField(uint8_t flag)
-{
-}
-
-void SignatureVisitor::VisitEndField()
-{
-}
-
-void SignatureVisitor::VisitBeginType(CorElementType elementType)
-{
-}
-
-void SignatureVisitor::VisitEndType()
-{
-}
-
-void SignatureVisitor::VisitTypeDefOrRefEncoded(CodedRidx<crid_TypeDefOrRef> cridx)
-{
-}
-
-void SignatureVisitor::VisitBeginMethod(uint8_t flag)
-{
-}
-
-void SignatureVisitor::VisitEndMethod()
-{
-}
-
-void SignatureVisitor::VisitParamCount(uint32_t count)
-{
-}
-
-void SignatureVisitor::VisitBeginRetType()
-{
-}
-
-void SignatureVisitor::VisitEndRetType()
-{
-}
-
-void SignatureVisitor::VisitBeginParam()
-{
-}
-
-void SignatureVisitor::VisitEndParam()
-{
-}
-
-void SignatureVisitor::VisitBeginLocalVars(uint8_t flag)
-{
-}
-
-void SignatureVisitor::VisitEndLocalVars()
-{
-}
-
-void SignatureVisitor::VisitLocalVarCount(uint32_t number)
-{
-}
-
-void SignatureVisitor::VisitBeginLocalVar()
-{
-}
-
-void SignatureVisitor::VisitEndLocalVar()
-{
-}
-
-void SignatureVisitor::VisitTypeGenericParamNumber(uint32_t number)
-{
-}
-
-void SignatureVisitor::VisitBeginSzArray()
-{
-}
-
-void SignatureVisitor::VisitEndSzArray()
-{
-}
-
-void SignatureVisitor::ParseLocals(SigParser& parser, uint8_t flag)
-{
-    VisitBeginLocalVars(flag);
-
-    auto localVarCount = parser.GetNumber();
-    VisitLocalVarCount(localVarCount);
-
-    for (size_t i = 0; i < localVarCount; i++)
-    {
-        ParseLocalVar(parser);
-    }
-
-    VisitEndLocalVars();
-}
-
-void SignatureVisitor::ParseProperty(SigParser& parser, uint8_t flag)
-{
-    assert(!"Not impl");
-}
-
-void SignatureVisitor::ParseOptionalCustomMods(SigParser& parser)
-{
-    while (true)
-    {
-        if (parser.IsEmpty())
-            break;
-
-        switch (parser.PeekByte())
-        {
-        case ELEMENT_TYPE_CMOD_OPT:
-        case ELEMENT_TYPE_CMOD_REQD:
-            ParseCustomMod(parser);
-            break;
-        default:
-            return;
-        }
-    }
-}
-
-void SignatureVisitor::ParseType(SigParser& parser)
-{
-    auto elemType = static_cast<CorElementType>(parser.GetByte());
-    VisitBeginType(elemType);
-
-    switch (elemType)
-    {
-    case ELEMENT_TYPE_BOOLEAN:
-    case ELEMENT_TYPE_CHAR:
-    case ELEMENT_TYPE_I1:
-    case ELEMENT_TYPE_U1:
-    case ELEMENT_TYPE_U2:
-    case ELEMENT_TYPE_I2:
-    case ELEMENT_TYPE_I4:
-    case ELEMENT_TYPE_U4:
-    case ELEMENT_TYPE_I8:
-    case ELEMENT_TYPE_U8:
-    case ELEMENT_TYPE_R4:
-    case ELEMENT_TYPE_R8:
-    case ELEMENT_TYPE_I:
-    case ELEMENT_TYPE_U:
-    case ELEMENT_TYPE_STRING:
-    case ELEMENT_TYPE_OBJECT:
-    case ELEMENT_TYPE_TYPEDBYREF:
-    case ELEMENT_TYPE_VOID:
-        break;
-    case ELEMENT_TYPE_CLASS:
-    case ELEMENT_TYPE_VALUETYPE:
-        ParseTypeDefOrRefEncoded(parser);
-        break;
-    case ELEMENT_TYPE_BYREF:
-        ParseType(parser);
-        break;
-    case ELEMENT_TYPE_VAR:
-        VisitTypeGenericParamNumber(parser.GetNumber());
-        break;
-    case ELEMENT_TYPE_SZARRAY:
-        VisitBeginSzArray();
-        ParseOptionalCustomMods(parser);
-        ParseType(parser);
-        VisitEndSzArray();
-        break;
-    case ELEMENT_TYPE_PTR:
-    case ELEMENT_TYPE_ARRAY:
-    case ELEMENT_TYPE_GENERICINST:
-    case ELEMENT_TYPE_MVAR:
-        THROW_ALWAYS(NotSupportedException);
-        break;
-    default:
-        assert(!"Not impl");
-        break;
-    }
-
-    VisitEndType();
-}
-
-void SignatureVisitor::ParseCustomMod(SigParser& parser)
-{
-    auto cmod = parser.GetByte();
-
-    if (cmod == ELEMENT_TYPE_CMOD_OPT || cmod == ELEMENT_TYPE_CMOD_REQD)
-        ParseTypeDefOrRefEncoded(parser);
-
-    assert(!"Invalid custom mod.");
-}
-
-void SignatureVisitor::ParseTypeDefOrRefEncoded(SigParser& parser)
-{
-    VisitTypeDefOrRefEncoded({ parser.GetNumber() });
-}
-
-void SignatureVisitor::ParseRetType(SigParser& parser)
-{
-    // RetType ::= CustomMod* ( VOID | TYPEDBYREF | [BYREF] Type )
-    VisitBeginRetType();
-
-    ParseOptionalCustomMods(parser);
-
-    ParseType(parser);
-
-    VisitEndRetType();
-}
-
-void SignatureVisitor::ParseParam(SigParser& parser)
-{
-    VisitBeginParam();
-
-    ParseOptionalCustomMods(parser);
-
-    ParseType(parser);
-
-    VisitEndParam();
-}
-
-void SignatureVisitor::ParseLocalVar(SigParser& parser)
-{
-    VisitBeginLocalVar();
-
-    ParseOptionalCustomMods(parser);
-
-    ParseType(parser);
-
-    VisitEndLocalVar();
-}

src/natsuclr/md/mddefs.cpp

@@ -1,7 +0,0 @@
-//
-// Natsu CLR Metadata
-//
-#include <md/mddefs.hpp>
-#include <utils.hpp>
-
-using namespace clr::metadata;

src/natsuclr/vm/CalleeInfo.cpp

@@ -1,46 +0,0 @@
-//
-// Natsu CLR VM
-//
-#include <cassert>
-#include <utils.hpp>
-#include <vm/EvaluationStack.hpp>
-
-using namespace clr;
-using namespace clr::vm;
-using namespace clr::metadata;
-
-CalleeInfo::CalleeInfo(const MethodDesc& method)
-    : method_(method)
-{
-    size_t offset = 0;
-    argPointer_ = offset;
-    offset = align(offset + method.GetParamSize(), method.GetLocalVarAlign());
-    localVarPointer_ = offset;
-    offset = align(offset + method.GetLocalVarSize(), method.GetRetAlign());
-    retPointer_ = offset;
-    offset += method.GetRetSize();
-
-    data_ = std::make_unique<uint8_t[]>(offset);
-}
-
-uint8_t* CalleeInfo::GetArg(size_t index, TypeDesc& type)
-{
-    assert(index < method_.ParamCount);
-    auto& var = method_.ParamDescs[index];
-    type = var.Type;
-    return &data_[argPointer_ + var.Offset];
-}
-
-uint8_t* CalleeInfo::GetLocalVar(size_t index, TypeDesc& type)
-{
-    assert(index < method_.LocalVarCount);
-    auto& var = method_.LocalVarDescs[index];
-    type = var.Type;
-    return &data_[localVarPointer_ + var.Offset];
-}
-
-uint8_t* CalleeInfo::GetRet(TypeDesc& type)
-{
-    type = method_.RetDesc;
-    return &data_[retPointer_];
-}

src/natsuclr/vm/ECall.cpp

@@ -1,120 +0,0 @@
-//
-// Natsu CLR VM
-//
-#include <classlibnative/System/Array.hpp>
-#include <classlibnative/System/Console.hpp>
-#include <classlibnative/System/Object.hpp>
-#include <cassert>
-#include <cstring>
-#include <utils.hpp>
-#include <vm/ECall.hpp>
-#include <vm/EvaluationStack.hpp>
-
-using namespace clr;
-using namespace clr::vm;
-
-template <typename Func>
-struct func_info;
-
-template <size_t I, typename... TArgs>
-struct arg_info
-{
-    using Type = std::tuple_element_t<I, std::tuple<TArgs...>>;
-};
-
-template <typename TRet, typename... TArgs>
-struct func_info<TRet (*)(TArgs...)>
-{
-    static const auto ArgsCount = sizeof...(TArgs);
-
-    static void Call(uintptr_t entryPoint, CalleeInfo& callee)
-    {
-        if constexpr (std::is_void_v<TRet>)
-        {
-            return CallImp(entryPoint, callee, std::make_index_sequence<ArgsCount>());
-        }
-        else
-        {
-            TypeDesc retType;
-            auto dest = callee.GetRet(retType);
-            assert(retType.GetStackSize() == align(sizeof(TRet), 8));
-            auto ret = CallImp(entryPoint, callee, std::make_index_sequence<ArgsCount>());
-            memcpy(dest, &ret, sizeof(TRet));
-        }
-    }
-
-private:
-    template <size_t N>
-    static auto ArgAt(CalleeInfo& callee)
-    {
-        using arg_t = arg_info<N, TArgs...>;
-        TypeDesc srcType;
-        return *reinterpret_cast<typename arg_t::Type*>(callee.GetArg(N, srcType));
-    }
-
-    template <size_t... ArgIdx>
-    static auto CallImp(uintptr_t entryPoint, CalleeInfo& callee, std::index_sequence<ArgIdx...>)
-    {
-        auto func = reinterpret_cast<TRet (*)(TArgs...)>(entryPoint);
-        return func(ArgAt<ArgIdx>(callee)...);
-    }
-};
-
-#define ECFuncStart(funcvar, ns, cls) static const ECall funcvar[] = {
-#define ECFuncElement(name, func) { name, uintptr_t(func), &func_info<decltype(func)>::Call },
-#define ECFuncEnd() \
-    {               \
-        {}, 0, 0    \
-    }               \
-    }               \
-    ;
-
-#include <vm/ECallList.hpp>
-
-#define ECFuncStart(funcvar, ns, cls) { ns, cls, funcvar },
-#define ECFuncElement(name, func)
-#define ECFuncEnd()
-
-static const ECallClass g_ECalls[] = {
-#include <vm/ECallList.hpp>
-    { {}, {}, nullptr }
-};
-
-const ECall& clr::vm::FindECall(const MethodDesc& method)
-{
-    bool found = false;
-
-    const ECallClass* ecallClass = g_ECalls;
-
-    {
-        auto ns = method.Class->TypeNamespace;
-        auto cls = method.Class->TypeName;
-        while (!ecallClass->Namespace.empty())
-        {
-            if (ecallClass->Namespace == ns)
-            {
-                if (ecallClass->ClassName == cls)
-                {
-                    found = true;
-                    break;
-                }
-            }
-
-            ecallClass++;
-        }
-    }
-
-    if (found)
-    {
-        auto name = method.Name;
-        const ECall* ecall = ecallClass->ECalls;
-        while (!ecall->MethodName.empty())
-        {
-            if (ecall->MethodName == name)
-                return *ecall;
-            ecall++;
-        }
-    }
-
-    THROW_ALWAYS(ECallNotFoundException);
-}

src/natsuclr/vm/EEClass.cpp

@@ -1,155 +0,0 @@
-//
-// Natsu CLR VM
-//
-#include <cassert>
-#include <classlibnative/System/Object.hpp>
-#include <vm/EEClass.hpp>
-
-using namespace clr;
-using namespace clr::corlib;
-using namespace clr::metadata;
-using namespace clr::vm;
-
-bool TypeDesc::IsEmpty() const noexcept
-{
-    return Type == 0;
-}
-
-size_t TypeDesc::GetStackSize() const noexcept
-{
-    assert(!(Flags & tda_ByRef));
-
-    assert(Type);
-
-    switch (Type)
-    {
-    case ELEMENT_TYPE_VOID:
-        return 0;
-    case ELEMENT_TYPE_BOOLEAN:
-    case ELEMENT_TYPE_CHAR:
-    case ELEMENT_TYPE_I1:
-    case ELEMENT_TYPE_U1:
-        return 1;
-    case ELEMENT_TYPE_I2:
-    case ELEMENT_TYPE_U2:
-        return 2;
-    case ELEMENT_TYPE_I4:
-    case ELEMENT_TYPE_U4:
-    case ELEMENT_TYPE_R4:
-        return 4;
-    case ELEMENT_TYPE_I8:
-    case ELEMENT_TYPE_U8:
-    case ELEMENT_TYPE_R8:
-        return 8;
-    case ELEMENT_TYPE_STRING:
-    case ELEMENT_TYPE_CLASS:
-    case ELEMENT_TYPE_ARRAY:
-    case ELEMENT_TYPE_SZARRAY:
-    case ELEMENT_TYPE_OBJECT:
-        return sizeof(ObjectRef<>);
-    case ELEMENT_TYPE_VALUETYPE:
-        assert(Class && Class->LoadLevel >= clsLoad_InstanceFields);
-        return Class->InstanceSize;
-    case ELEMENT_TYPE_I:
-        return sizeof(intptr_t);
-    case ELEMENT_TYPE_U:
-        return sizeof(uintptr_t);
-    case ELEMENT_TYPE_VAR:
-        return 0;
-    default:
-        assert(!"Invalid type.");
-        return 0;
-    }
-}
-
-size_t TypeDesc::GetAlign() const noexcept
-{
-    assert(!(Flags & tda_ByRef));
-
-    assert(Type);
-
-    switch (Type)
-    {
-    case ELEMENT_TYPE_VOID:
-    case ELEMENT_TYPE_BOOLEAN:
-    case ELEMENT_TYPE_CHAR:
-    case ELEMENT_TYPE_I1:
-    case ELEMENT_TYPE_U1:
-        return 1;
-    case ELEMENT_TYPE_I2:
-    case ELEMENT_TYPE_U2:
-        return 2;
-    case ELEMENT_TYPE_I4:
-    case ELEMENT_TYPE_U4:
-    case ELEMENT_TYPE_R4:
-        return 4;
-    case ELEMENT_TYPE_I8:
-    case ELEMENT_TYPE_U8:
-    case ELEMENT_TYPE_R8:
-        return 8;
-    case ELEMENT_TYPE_STRING:
-    case ELEMENT_TYPE_CLASS:
-    case ELEMENT_TYPE_ARRAY:
-    case ELEMENT_TYPE_SZARRAY:
-    case ELEMENT_TYPE_OBJECT:
-        return sizeof(ObjectRef<>);
-    case ELEMENT_TYPE_VALUETYPE:
-        assert(Class && Class->LoadLevel >= clsLoad_InstanceFields);
-        return Class->Align;
-    case ELEMENT_TYPE_I:
-        return sizeof(intptr_t);
-    case ELEMENT_TYPE_U:
-        return sizeof(uintptr_t);
-    case ELEMENT_TYPE_VAR:
-        return 1;
-    default:
-        assert(!"Invalid type.");
-        return 1;
-    }
-}
-
-size_t MethodDesc::GetParamSize() const
-{
-    if (ParamCount)
-    {
-        auto& desc = ParamDescs[ParamCount - 1];
-        return desc.Offset + desc.Type.GetStackSize();
-    }
-
-    return 0;
-}
-
-size_t MethodDesc::GetLocalVarSize() const
-{
-    if (LocalVarCount)
-    {
-        auto& desc = LocalVarDescs[LocalVarCount - 1];
-        return desc.Offset + desc.Type.GetStackSize();
-    }
-
-    return 0;
-}
-
-size_t MethodDesc::GetRetSize() const
-{
-    return RetDesc.GetStackSize();
-}
-
-size_t MethodDesc::GetParamAlign() const
-{
-    if (ParamCount)
-        return ParamDescs[0].Type.GetAlign();
-    return 1;
-}
-
-size_t MethodDesc::GetLocalVarAlign() const
-{
-    if (LocalVarCount)
-        return LocalVarDescs[0].Type.GetAlign();
-    return 1;
-}
-
-size_t MethodDesc::GetRetAlign() const
-{
-    return RetDesc.GetAlign();
-}

src/natsuclr/vm/EvaluationStack.cpp

@@ -1,82 +0,0 @@
-//
-// Natsu CLR VM
-//
-#include <cassert>
-#include <gc/gc.hpp>
-#include <utils.hpp>
-#include <vm/EvaluationStack.hpp>
-
-using namespace clr;
-using namespace clr::corlib;
-using namespace clr::gc;
-using namespace clr::vm;
-using namespace clr::metadata;
-
-EvaluationStack::EvaluationStack(size_t stackSize)
-    : stackSize_(stackSize), stack_(std::make_unique<uint8_t[]>(stackSize)), stackPointer_(0)
-{
-}
-
-void EvaluationStack::PushVar(const void* value, const TypeDesc& type)
-{
-    auto size = type.GetStackSize();
-    auto offset = align(stackPointer_, type.GetAlign());
-    THROW_IF_NOT(offset + size <= stackSize_, StackOverflowException);
-
-    VarDesc var { (uint32_t)offset, type };
-    stackVars_.emplace_back(var);
-    memcpy(&stack_[offset], value, size);
-    stackPointer_ += offset + size;
-}
-
-uint8_t* EvaluationStack::GetTopVar(TypeDesc& type)
-{
-    assert(!stackVars_.empty());
-    auto& top = stackVars_.back();
-    type = top.Type;
-    return &stack_[top.Offset];
-}
-
-void EvaluationStack::PopVar()
-{
-    assert(!stackVars_.empty());
-    stackVars_.pop_back();
-
-    if (stackVars_.empty())
-    {
-        stackPointer_ = 0;
-    }
-    else
-    {
-        auto& top = stackVars_.back();
-        stackPointer_ = top.Offset + top.Type.GetStackSize();
-    }
-}
-
-uint8_t* EvaluationStack::PopTopVar(TypeDesc& type)
-{
-    auto data = GetTopVar(type);
-    PopVar();
-    return data;
-}
-
-void EvaluationStack::PushFrame(const MethodDesc& method)
-{
-    FrameMarker marker { method, stackVars_.size() };
-    frames_.emplace(marker);
-}
-
-void EvaluationStack::PopFrame()
-{
-    stackVars_.resize(frames_.top().VarsOffset);
-
-    if (stackVars_.empty())
-    {
-        stackPointer_ = 0;
-    }
-    else
-    {
-        auto& top = stackVars_.back();
-        stackPointer_ = top.Offset + top.Type.GetStackSize();
-    }
-}

src/natsuclr/vm/Interpreter.cpp

@@ -1,576 +0,0 @@
-//
-// Natsu CLR VM
-//
-#include <binder/CorlibBinder.hpp>
-#include <gc/gc.hpp>
-#include <utils.hpp>
-#include <vm/Interpreter.hpp>
-
-using namespace clr;
-using namespace clr::corlib;
-using namespace clr::gc;
-using namespace clr::vm;
-using namespace clr::metadata;
-
-Interpreter::Interpreter(loader::AssemblyLoader& assemblyLoader)
-    : assemblyLoader_(assemblyLoader)
-{
-}
-
-class CallHelper
-{
-public:
-    CallHelper(const MethodDesc& method, CalleeInfo& calleeInfo, EvaluationStack& stack)
-        : method_(method), calleeInfo_(calleeInfo), stack_(stack)
-    {
-    }
-
-    void BeginCall()
-    {
-        for (int32_t i = (int32_t)method_.ParamCount - 1; i >= 0; i--)
-        {
-            TypeDesc srcType, destType;
-            auto src = stack_.GetTopVar(srcType);
-            auto dest = calleeInfo_.GetArg(i, destType);
-            assert(srcType.GetStackSize() == destType.GetStackSize());
-            memcpy(dest, src, srcType.GetStackSize());
-            stack_.PopVar();
-        }
-
-        stack_.PushFrame(method_);
-    }
-
-    void EndCall(bool hasRet)
-    {
-        stack_.PopFrame();
-
-        if (hasRet)
-        {
-            TypeDesc srcType;
-            auto src = calleeInfo_.GetRet(srcType);
-            if (srcType.Type != ELEMENT_TYPE_VOID)
-                stack_.PushVar(src, srcType);
-        }
-    }
-
-private:
-    const MethodDesc& method_;
-    CalleeInfo& calleeInfo_;
-    EvaluationStack& stack_;
-};
-
-TypeDesc ClassToType(EEClass* cls)
-{
-    CorElementType type;
-    auto& types = CorlibBinder::Current().Types;
-    if (cls == types.Boolean)
-        type = ELEMENT_TYPE_BOOLEAN;
-    else if (cls == types.Double)
-        type = ELEMENT_TYPE_R8;
-    else if (cls == types.Int16)
-        type = ELEMENT_TYPE_I2;
-    else if (cls == types.Int32)
-        type = ELEMENT_TYPE_I4;
-    else if (cls == types.Object)
-        type = ELEMENT_TYPE_OBJECT;
-    else if (cls == types.Single)
-        type = ELEMENT_TYPE_R4;
-    else if (cls == types.UInt32)
-        type = ELEMENT_TYPE_U4;
-    else if (cls == types.Void)
-        type = ELEMENT_TYPE_VOID;
-    else
-        type = ELEMENT_TYPE_CLASS;
-    return { tda_Normal, type, 0, cls };
-}
-
-void Interpreter::ExecuteMethod(const MethodDesc& method)
-{
-    auto& calleeInfo = calleeInfo_.emplace(method);
-    CallHelper callHelper(method, calleeInfo, evalStack_);
-    callHelper.BeginCall();
-
-    if (method.IsECall)
-        method.ECall.Call(method.ECall.EntryPoint, calleeInfo);
-    else
-        ExecuteILMethod(method);
-
-    callHelper.EndCall(true);
-    calleeInfo_.pop();
-}
-
-void Interpreter::ExecuteILMethod(const MethodDesc& method)
-{
-    IP_.push(method.BodyBegin);
-    while (true)
-    {
-        OpInfo op(static_cast<OPCODE>(*IP_.top()));
-        OpArgsVal opArgs;
-        IP_.top() = op.fetch(IP_.top(), &opArgs);
-
-        ExecuteOp(op, opArgs);
-
-        switch (op.getFlow())
-        {
-        case FLOW_RETURN:
-            IP_.pop();
-            return;
-        default:
-            break;
-        }
-    }
-}
-
-template <>
-void Interpreter::ExecuteOp<CEE_NOP>(OpInfo& op, OpArgsVal& args)
-{
-}
-
-template <>
-void Interpreter::ExecuteOp<CEE_RET>(OpInfo& op, OpArgsVal& args)
-{
-}
-
-template <>
-void Interpreter::ExecuteOp<CEE_CALL>(OpInfo& op, OpArgsVal& args)
-{
-    mdToken token(static_cast<uint32_t>(args.i));
-    const MethodDesc* method;
-
-    switch (token.GetType())
-    {
-    case mdt_MethodDef:
-        method = &assemblyLoader_.GetMethod(token.As<mdt_MethodDef>());
-        break;
-    default:
-        assert(!"Invalid token type");
-        break;
-    }
-
-    ExecuteMethod(*method);
-}
-
-#define IMP_LDARG(op, val)                                         \
-    template <>                                                    \
-    void Interpreter::ExecuteOp<op>(OpInfo & op, OpArgsVal & args) \
-    {                                                              \
-        ExecuteOp_LDARG(static_cast<size_t>(val));                 \
-    }
-
-IMP_LDARG(CEE_LDARG, args.i)
-IMP_LDARG(CEE_LDARG_S, args.i)
-IMP_LDARG(CEE_LDARG_0, 0)
-IMP_LDARG(CEE_LDARG_1, 1)
-IMP_LDARG(CEE_LDARG_2, 2)
-IMP_LDARG(CEE_LDARG_3, 3)
-
-#define IMP_LDLOC(op, val)                                         \
-    template <>                                                    \
-    void Interpreter::ExecuteOp<op>(OpInfo & op, OpArgsVal & args) \
-    {                                                              \
-        ExecuteOp_LDLOC(static_cast<size_t>(val));                 \
-    }
-
-IMP_LDLOC(CEE_LDLOC, args.i)
-IMP_LDLOC(CEE_LDLOC_S, args.i)
-IMP_LDLOC(CEE_LDLOC_0, 0)
-IMP_LDLOC(CEE_LDLOC_1, 1)
-IMP_LDLOC(CEE_LDLOC_2, 2)
-IMP_LDLOC(CEE_LDLOC_3, 3)
-
-#define IMP_STLOC(op, val)                                         \
-    template <>                                                    \
-    void Interpreter::ExecuteOp<op>(OpInfo & op, OpArgsVal & args) \
-    {                                                              \
-        ExecuteOp_STLOC(static_cast<size_t>(val));                 \
-    }
-
-IMP_STLOC(CEE_STLOC, args.i)
-IMP_STLOC(CEE_STLOC_S, args.i)
-IMP_STLOC(CEE_STLOC_0, 0)
-IMP_STLOC(CEE_STLOC_1, 1)
-IMP_STLOC(CEE_STLOC_2, 2)
-IMP_STLOC(CEE_STLOC_3, 3)
-
-#define IMP_LDC_I4(op, val)                                        \
-    template <>                                                    \
-    void Interpreter::ExecuteOp<op>(OpInfo & op, OpArgsVal & args) \
-    {                                                              \
-        ExecuteOp_LDC_I4(static_cast<size_t>(val));                \
-    }
-
-IMP_LDC_I4(CEE_LDC_I4, args.i)
-IMP_LDC_I4(CEE_LDC_I4_S, args.i)
-IMP_LDC_I4(CEE_LDC_I4_0, 0)
-IMP_LDC_I4(CEE_LDC_I4_1, 1)
-IMP_LDC_I4(CEE_LDC_I4_2, 2)
-IMP_LDC_I4(CEE_LDC_I4_3, 3)
-IMP_LDC_I4(CEE_LDC_I4_4, 4)
-IMP_LDC_I4(CEE_LDC_I4_5, 5)
-IMP_LDC_I4(CEE_LDC_I4_6, 6)
-IMP_LDC_I4(CEE_LDC_I4_7, 7)
-IMP_LDC_I4(CEE_LDC_I4_8, 8)
-
-template <>
-void Interpreter::ExecuteOp<CEE_LDC_R4>(OpInfo& op, OpArgsVal& args)
-{
-    auto f = static_cast<float>(args.r);
-    evalStack_.PushVar(&f, { tda_Normal, ELEMENT_TYPE_R4, 0, CorlibBinder::Current().Types.Single });
-}
-
-template <>
-void Interpreter::ExecuteOp<CEE_LDC_R8>(OpInfo& op, OpArgsVal& args)
-{
-    evalStack_.PushVar(&args.r, { tda_Normal, ELEMENT_TYPE_R8, 0, CorlibBinder::Current().Types.Double });
-}
-
-template <>
-void Interpreter::ExecuteOp<CEE_CONV_R4>(OpInfo& op, OpArgsVal& args)
-{
-    float value;
-    TypeDesc srcType;
-    auto src = evalStack_.GetTopVar(srcType);
-    switch (srcType.Type)
-    {
-    case ELEMENT_TYPE_R8:
-        value = static_cast<float>(*reinterpret_cast<double*>(src));
-        break;
-    default:
-        THROW_ALWAYS(NotSupportedException);
-        break;
-    }
-
-    evalStack_.PopVar();
-    evalStack_.PushVar(&value, { tda_Normal, ELEMENT_TYPE_R4, 0, CorlibBinder::Current().Types.Single });
-}
-
-template <>
-void Interpreter::ExecuteOp<CEE_BR_S>(OpInfo& op, OpArgsVal& args)
-{
-    IP_.top() += args.i;
-}
-
-template <>
-void Interpreter::ExecuteOp<CEE_NEWOBJ>(OpInfo& op, OpArgsVal& args)
-{
-    mdToken token(static_cast<uint32_t>(args.i));
-    const MethodDesc* method;
-
-    switch (token.GetType())
-    {
-    case mdt_MethodDef:
-        method = &assemblyLoader_.GetMethod(token.As<mdt_MethodDef>());
-        break;
-    default:
-        assert(!"Invalid token type");
-        break;
-    }
-
-    auto type = ClassToType(method->Class);
-
-    auto obj = GC::Current().AllocateObject(type.Class);
-    evalStack_.PushVar(&obj, type);
-
-    ExecuteMethod(*method);
-    evalStack_.PushVar(&obj, type);
-}
-
-template <>
-void Interpreter::ExecuteOp<CEE_LDFLD>(OpInfo& op, OpArgsVal& args)
-{
-    mdToken token(static_cast<uint32_t>(args.i));
-    const FieldDesc* field;
-
-    switch (token.GetType())
-    {
-    case mdt_Field:
-        field = &assemblyLoader_.GetField(token.As<mdt_Field>());
-        break;
-    default:
-        assert(!"Invalid token type");
-        break;
-    }
-
-    TypeDesc objType;
-    auto obj = reinterpret_cast<ObjectRef<>*>(evalStack_.GetTopVar(objType));
-    auto offset = reinterpret_cast<uint8_t*>(obj->Get()) + field->Var.Offset;
-
-    evalStack_.PopVar();
-    evalStack_.PushVar(offset, field->Var.Type);
-}
-
-template <>
-void Interpreter::ExecuteOp<CEE_STFLD>(OpInfo& op, OpArgsVal& args)
-{
-    mdToken token(static_cast<uint32_t>(args.i));
-    const FieldDesc* field;
-
-    switch (token.GetType())
-    {
-    case mdt_Field:
-        field = &assemblyLoader_.GetField(token.As<mdt_Field>());
-        break;
-    default:
-        assert(!"Invalid token type");
-        break;
-    }
-
-    TypeDesc objType, srcType;
-    auto src = evalStack_.GetTopVar(srcType);
-    evalStack_.PopVar();
-
-    auto obj = reinterpret_cast<ObjectRef<>*>(evalStack_.GetTopVar(objType));
-    auto dest = reinterpret_cast<uint8_t*>(obj->Get()) + field->Var.Offset;
-    assert(srcType.GetStackSize() == field->Var.Type.GetStackSize());
-    memcpy(dest, src, srcType.GetStackSize());
-    evalStack_.PopVar();
-}
-
-template <>
-void Interpreter::ExecuteOp<CEE_NEWARR>(OpInfo& op, OpArgsVal& args)
-{
-    mdToken token(static_cast<uint32_t>(args.i));
-    EEClass* cls;
-
-    switch (token.GetType())
-    {
-    case mdt_TypeDef:
-        cls = &assemblyLoader_.GetClass(token.As<mdt_TypeDef>());
-        break;
-    default:
-        assert(!"Invalid token type");
-        break;
-    }
-
-    auto obj = GC::Current().AllocateArray(cls, PopIndexOrArrayLength());
-    evalStack_.PushVar(&obj, { tda_Normal | tda_SzArray, ELEMENT_TYPE_SZARRAY, 0, cls });
-}
-
-template <>
-void Interpreter::ExecuteOp<CEE_DUP>(OpInfo& op, OpArgsVal& args)
-{
-    TypeDesc srcType;
-    auto src = reinterpret_cast<ObjectRef<>*>(evalStack_.GetTopVar(srcType));
-    evalStack_.PushVar(src, srcType);
-}
-
-#define IMP_STELEM(op, type)                                       \
-    template <>                                                    \
-    void Interpreter::ExecuteOp<op>(OpInfo & op, OpArgsVal & args) \
-    {                                                              \
-        ExecuteOp_STELEM(type);                                    \
-    }
-
-IMP_STELEM(CEE_STELEM_I1, ELEMENT_TYPE_I1)
-IMP_STELEM(CEE_STELEM_I2, ELEMENT_TYPE_I2)
-IMP_STELEM(CEE_STELEM_I4, ELEMENT_TYPE_I4)
-IMP_STELEM(CEE_STELEM_I8, ELEMENT_TYPE_I8)
-IMP_STELEM(CEE_STELEM_R4, ELEMENT_TYPE_R4)
-IMP_STELEM(CEE_STELEM_R8, ELEMENT_TYPE_R8)
-IMP_STELEM(CEE_STELEM_I, ELEMENT_TYPE_I)
-IMP_STELEM(CEE_STELEM_REF, ELEMENT_TYPE_BYREF)
-
-#define EXECUTE_OP(opCode)           \
-    case opCode:                     \
-        ExecuteOp<opCode>(op, args); \
-        break;
-
-void Interpreter::ExecuteOp(OpInfo& op, OpArgsVal& args)
-{
-    switch (op.getOpcode())
-    {
-        EXECUTE_OP(CEE_NOP);
-        EXECUTE_OP(CEE_RET);
-        EXECUTE_OP(CEE_CALL);
-        EXECUTE_OP(CEE_LDARG);
-        EXECUTE_OP(CEE_LDARG_S);
-        EXECUTE_OP(CEE_LDARG_0);
-        EXECUTE_OP(CEE_LDARG_1);
-        EXECUTE_OP(CEE_LDARG_2);
-        EXECUTE_OP(CEE_LDARG_3);
-        EXECUTE_OP(CEE_LDLOC);
-        EXECUTE_OP(CEE_LDLOC_S);
-        EXECUTE_OP(CEE_LDLOC_0);
-        EXECUTE_OP(CEE_LDLOC_1);
-        EXECUTE_OP(CEE_LDLOC_2);
-        EXECUTE_OP(CEE_LDLOC_3);
-        EXECUTE_OP(CEE_STLOC);
-        EXECUTE_OP(CEE_STLOC_S);
-        EXECUTE_OP(CEE_STLOC_0);
-        EXECUTE_OP(CEE_STLOC_1);
-        EXECUTE_OP(CEE_STLOC_2);
-        EXECUTE_OP(CEE_STLOC_3);
-        EXECUTE_OP(CEE_LDC_I4);
-        EXECUTE_OP(CEE_LDC_I4_S);
-        EXECUTE_OP(CEE_LDC_I4_0);
-        EXECUTE_OP(CEE_LDC_I4_1);
-        EXECUTE_OP(CEE_LDC_I4_2);
-        EXECUTE_OP(CEE_LDC_I4_3);
-        EXECUTE_OP(CEE_LDC_I4_4);
-        EXECUTE_OP(CEE_LDC_I4_5);
-        EXECUTE_OP(CEE_LDC_I4_6);
-        EXECUTE_OP(CEE_LDC_I4_7);
-        EXECUTE_OP(CEE_LDC_I4_8);
-        EXECUTE_OP(CEE_LDC_R4);
-        EXECUTE_OP(CEE_LDC_R8);
-        EXECUTE_OP(CEE_CONV_R4);
-        EXECUTE_OP(CEE_BR_S);
-        EXECUTE_OP(CEE_NEWOBJ);
-        EXECUTE_OP(CEE_NEWARR);
-        EXECUTE_OP(CEE_DUP);
-        EXECUTE_OP(CEE_LDFLD);
-        EXECUTE_OP(CEE_STFLD);
-        EXECUTE_OP(CEE_STELEM_I1);
-        EXECUTE_OP(CEE_STELEM_I2);
-        EXECUTE_OP(CEE_STELEM_I4);
-        EXECUTE_OP(CEE_STELEM_I8);
-        EXECUTE_OP(CEE_STELEM_R4);
-        EXECUTE_OP(CEE_STELEM_R8);
-        EXECUTE_OP(CEE_STELEM_I);
-        EXECUTE_OP(CEE_STELEM_REF);
-    default:
-        assert(!"Invalid OpCode");
-        break;
-    }
-}
-
-void Interpreter::ExecuteOp_LDARG(size_t index)
-{
-    TypeDesc srcType;
-    auto& calleeInfo = calleeInfo_.top();
-    auto src = calleeInfo.GetArg(index, srcType);
-    evalStack_.PushVar(src, srcType);
-}
-
-void Interpreter::ExecuteOp_LDLOC(size_t index)
-{
-    TypeDesc srcType;
-    auto& calleeInfo = calleeInfo_.top();
-    auto src = calleeInfo.GetLocalVar(index, srcType);
-    evalStack_.PushVar(src, srcType);
-}
-
-void Interpreter::ExecuteOp_STLOC(size_t index)
-{
-    TypeDesc srcType, destType;
-    auto& calleeInfo = calleeInfo_.top();
-    auto src = evalStack_.GetTopVar(srcType);
-    auto dest = calleeInfo.GetLocalVar(0, destType);
-    assert(srcType.GetStackSize() == destType.GetStackSize());
-    memcpy(dest, src, srcType.GetStackSize());
-    evalStack_.PopVar();
-}
-
-void Interpreter::ExecuteOp_LDC_I4(int32_t i)
-{
-    evalStack_.PushVar(&i, { tda_Normal, ELEMENT_TYPE_I4, 0, CorlibBinder::Current().Types.Int32 });
-}
-
-void Interpreter::ExecuteOp_STELEM(CorElementType type)
-{
-    TypeDesc valType, arrType;
-    auto valSrc = evalStack_.PopTopVar(valType);
-
-    auto index = PopIndexOrArrayLength();
-    auto arr = *reinterpret_cast<ObjectRef<Array>*>(evalStack_.PopTopVar(arrType));
-    auto elemType = ClassToType(arr->GetHeader().Class);
-    assert(elemType.Flags | tda_SzArray);
-    assert(type != ELEMENT_TYPE_BYREF || elemType.Type == ELEMENT_TYPE_BYREF);
-
-    union {
-        uint64_t ival;
-        double rval;
-        uintptr_t refval;
-    } val;
-    bool isRealVal = false;
-
-    switch (type)
-    {
-    case ELEMENT_TYPE_I1:
-        val.ival = *reinterpret_cast<uint8_t*>(valSrc);
-        break;
-    case ELEMENT_TYPE_I2:
-        val.ival = *reinterpret_cast<uint16_t*>(valSrc);
-        break;
-    case ELEMENT_TYPE_I4:
-        val.ival = *reinterpret_cast<uint32_t*>(valSrc);
-        break;
-    case ELEMENT_TYPE_I8:
-        val.ival = *reinterpret_cast<uint64_t*>(valSrc);
-        break;
-    case ELEMENT_TYPE_R4:
-        val.rval = *reinterpret_cast<float*>(valSrc);
-        isRealVal = true;
-        break;
-    case ELEMENT_TYPE_R8:
-        val.rval = *reinterpret_cast<double*>(valSrc);
-        isRealVal = true;
-        break;
-    case ELEMENT_TYPE_BYREF:
-        val.refval = *reinterpret_cast<uintptr_t*>(valSrc);
-        break;
-    default:
-        assert(!"Invalid type.");
-        break;
-    }
-
-    if (!isRealVal && (arrType.Type == ELEMENT_TYPE_R4 || arrType.Type == ELEMENT_TYPE_R8))
-        val.rval = static_cast<double>(val.ival);
-    if (isRealVal && (arrType.Type >= ELEMENT_TYPE_BOOLEAN && arrType.Type <= ELEMENT_TYPE_U8))
-        val.ival = (uint64_t)round(val.rval);
-
-    switch (elemType.Type)
-    {
-    case ELEMENT_TYPE_BOOLEAN:
-    case ELEMENT_TYPE_I1:
-    case ELEMENT_TYPE_U1:
-        arr->At<uint8_t>(index) = static_cast<uint8_t>(val.ival);
-        break;
-    case ELEMENT_TYPE_CHAR:
-    case ELEMENT_TYPE_I2:
-    case ELEMENT_TYPE_U2:
-        arr->At<uint16_t>(index) = static_cast<uint16_t>(val.ival);
-        break;
-    case ELEMENT_TYPE_I4:
-    case ELEMENT_TYPE_U4:
-        arr->At<uint32_t>(index) = static_cast<uint32_t>(val.ival);
-        break;
-    case ELEMENT_TYPE_I8:
-    case ELEMENT_TYPE_U8:
-        arr->At<uint64_t>(index) = val.ival;
-        break;
-    case ELEMENT_TYPE_R4:
-        arr->At<float>(index) = static_cast<float>(val.rval);
-        break;
-    case ELEMENT_TYPE_R8:
-        arr->At<double>(index) = val.rval;
-        break;
-    case ELEMENT_TYPE_BYREF:
-        arr->At<uintptr_t>(index) = val.refval;
-        break;
-    default:
-        assert(!"Invalid type.");
-        break;
-    }
-}
-
-uint64_t Interpreter::PopIndexOrArrayLength()
-{
-    TypeDesc lenType;
-    auto lenSrc = evalStack_.GetTopVar(lenType);
-    uint64_t len;
-    switch (lenType.Type)
-    {
-    case ELEMENT_TYPE_I4:
-        len = *reinterpret_cast<int32_t*>(lenSrc);
-        break;
-    case ELEMENT_TYPE_I:
-        len = *reinterpret_cast<intptr_t*>(lenSrc);
-        break;
-    default:
-        assert(!"Invalid num elements type");
-        break;
-    }
-    evalStack_.PopVar();
-    return len;
-}

src/natsuclr/vm/Thread.cpp

@@ -1,17 +0,0 @@
-//
-// Natsu CLR VM
-//
-#include <vm/Thread.hpp>
-#include <vm/Interpreter.hpp>
-#include <utils.hpp>
-
-using namespace clr;
-using namespace clr::vm;
-using namespace clr::metadata;
-
-void Thread::Execute(const MethodDesc& method)
-{
-	Interpreter interpreter(*assemblyLoader_);
-
-	interpreter.ExecuteMethod(method);
-}

src/natsuclr/vm/opinfo.cpp

@@ -1,141 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-/***************************************************************************/
-/*                                OpInfo.cpp                               */
-/***************************************************************************/
-
-#include <vm/opinfo.h>
-#include <cstring>
-
-
-OpInfo::OpInfoData OpInfo::table[] = {
-
-#define OPDEF(c,s,pop,push,args,type,l,s1,s2,ctrl) \
-    { s, (OPCODE_FORMAT) (args + type), FLOW_ ## ctrl, pop, push, c },
-
-    // Kind of a workaround, get the prefixes (IInternal) to return InlineOpcode instead of InlineNone
-#define IInternal   (InlineOpcode - InlineNone)
-#define IMacro      0
-#define IPrimitive  0
-#define IAnnotation 0
-#define IObjModel   0
-#define IPrefix     0
-
-#define Pop0    0
-#define Pop1    1
-#define PopI    1
-#define PopI4   1
-#define PopR4   1
-#define PopI8   1
-#define PopR8   1
-#define PopRef  1
-#define VarPop  -1
-
-#define Push0    0
-#define Push1    1
-#define PushI    1
-#define PushI4   1
-#define PushR4   1
-#define PushI8   1
-#define PushR8   1
-#define PushRef  1
-#define VarPush  -1
-
-#include "opcode.def"
-#undef OPDEF
-};
-
-inline uint16_t GET_UNALIGNED_16(const void *pObject)
-{
-	uint16_t temp;
-	memcpy(&temp, pObject, sizeof(temp));
-	return temp;
-}
-inline uint32_t GET_UNALIGNED_32(const void *pObject)
-{
-	uint32_t temp;
-	memcpy(&temp, pObject, sizeof(temp));
-	return temp;
-}
-inline uint64_t GET_UNALIGNED_64(const void *pObject)
-{
-	uint64_t temp;
-	memcpy(&temp, pObject, sizeof(temp));
-	return temp;
-}
-#define VAL16(x) x
-#define VAL32(x) x
-#define VAL64(x) x
-
-#define GET_UNALIGNED_VAL16(_pObject) VAL16(GET_UNALIGNED_16(_pObject))
-#define GET_UNALIGNED_VAL32(_pObject) VAL32(GET_UNALIGNED_32(_pObject))
-#define GET_UNALIGNED_VAL64(_pObject) VAL64(GET_UNALIGNED_64(_pObject))
-
-/***************************************************************************/
-/* parse instruction at 'instrPtr', into its opcode (OpInfo), and its
-   (inline)args, 'args'  'instrPtr' is updated */
-
-/***************************************************************************/
-const uint8_t* OpInfo::fetch(const uint8_t* instrPtr, OpArgsVal* args) {
-
-    data = &table[*instrPtr++];
-AGAIN:
-    assert(data - table == data->opcode);
-    switch(data->format) {
-        case InlineNone:
-            break;
-        case InlineOpcode:
-            assert(*instrPtr + 256 < (int) (sizeof(table) / sizeof(OpInfoData)));
-            data = &table[256 + *instrPtr++];
-            goto AGAIN;
-
-        case ShortInlineVar:
-            args->i = *instrPtr; instrPtr +=1;
-            break;
-        case InlineVar:
-            args->i = GET_UNALIGNED_VAL16(instrPtr); instrPtr +=2;
-            break;
-        case ShortInlineI:
-        case ShortInlineBrTarget:
-            args->i = *instrPtr; instrPtr +=1;
-            break;
-        case ShortInlineR: {
-            uint32_t f = GET_UNALIGNED_VAL32(instrPtr); instrPtr +=4;
-            args->r = *((float*) (&f));
-            }
-            break;
-        case InlineRVA:
-        case InlineI:
-        case InlineMethod:
-        case InlineField:
-        case InlineType:
-        case InlineString:
-        case InlineSig:
-        case InlineTok:
-        case InlineBrTarget:
-            args->i = GET_UNALIGNED_VAL32(instrPtr); instrPtr +=4;
-            break;
-        case InlineI8:
-            args->i8 = GET_UNALIGNED_VAL64(instrPtr); instrPtr +=8;
-            break;
-        case InlineR: {
-            uint64_t d = GET_UNALIGNED_VAL64(instrPtr); instrPtr +=8;
-            args->r = *((double*) (&d));
-            } break;
-        case InlineSwitch:
-            args->switch_.count   = GET_UNALIGNED_VAL32(instrPtr); instrPtr +=4;
-            args->switch_.targets = (int*) instrPtr; instrPtr += (4 * args->switch_.count);
-            break;
-        case InlinePhi:
-            args->phi.count = GET_UNALIGNED_VAL32(instrPtr); instrPtr +=1;
-            args->phi.vars  = (unsigned short*) instrPtr; instrPtr += (2 * args->phi.count);
-            break;
-        default:
-            assert(!"BadType");
-            break;
-        }
-    return(instrPtr);
-}
-

src/tests/CMakeLists.txt

@@ -1,10 +0,0 @@
-
-INCLUDE_DIRECTORIES(../natsuclr/include)
-
-FILE(GLOB_RECURSE TESTS_SRC "*.c" "*.cpp")
-
-ADD_EXECUTABLE(tests ${TESTS_SRC})
-
-TARGET_LINK_LIBRARIES(tests natsuclr)
-SET_TARGET_PROPERTIES(tests PROPERTIES
-							LINKER_LANGUAGE CXX)

src/tests/main.cpp

@@ -1,45 +0,0 @@
-//
-//
-#include <iostream>
-#include <vector>
-#include <Windows.h>
-#include <cassert>
-#include <loader/AssemblyLoader.hpp>
-#include <binder/Binder.hpp>
-#include <binder/CorlibBinder.hpp>
-#include <vm/Thread.hpp>
-
-using namespace clr;
-using namespace clr::loader;
-using namespace clr::metadata;
-using namespace clr::vm;
-
-std::vector<uint8_t> load_file(const char* filename)
-{
-	auto handle = CreateFileA(filename, GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, 0);
-	assert(handle != INVALID_HANDLE_VALUE);
-	auto size = GetFileSize(handle, nullptr);
-	std::vector<uint8_t> data;
-	data.resize(size);
-	DWORD read = 0;
-	auto hr = ReadFile(handle, data.data(), size, &read, nullptr);
-	assert(hr);
-	return data;
-}
-
-void dummy_deleter(const uint8_t* ptr)
-{
-}
-
-int main()
-{
-	auto file = load_file(__FILE__ R"(\..\..\System.Private.CorLib\bin\Debug\netstandard2.0\System.Private.CorLib.dll)");
-	auto asmfile = std::make_shared<AssemblyFile>(std::shared_ptr<const uint8_t[]>(file.data(), dummy_deleter), file.size());
-	auto loader = std::make_shared<AssemblyLoader>(asmfile);
-	loader->Load();
-
-    CorlibBinder::Initialize(loader);
-	Thread thread;
-	thread.assemblyLoader_ = loader.get();
-	thread.Execute(*CorlibBinder::Current().BindMethod("System", "Console", "Test"));
-}