Unify symbol reference handling

include/vast/CodeGen/ScopeContext.hpp

@@ -1,4 +1,4 @@
 // Copyright (c) 2023, Trail of Bits, Inc.
 
 #pragma once
 
@@ -32,7 +32,7 @@
     };
 
     using funs_scope_table     = scoped_table< string_ref, operation >;
-    using vars_scope_table     = scoped_table< string_ref, mlir_value >;
+    using vars_scope_table     = scoped_table< string_ref, operation >;
     using types_scope_table    = scoped_table< string_ref, operation >;
     using members_scope_table  = scoped_table< string_ref, operation >;
     using labels_scope_table   = scoped_table< string_ref, operation >;
@@ -57,7 +57,7 @@
         operation declare(operation op) {
             llvm::TypeSwitch< operation >(op)
                 .Case< core::VarSymbolOpInterface >([&] (auto &op) {
-                    symbols.vars.insert(op.getSymbolName(), op->getResult(0));
+                    symbols.vars.insert(op.getSymbolName(), op);
                 })
                 .Case< core::TypeSymbolOpInterface >([&] (auto &op) {
                     symbols.types.insert(op.getSymbolName(), op);
@@ -90,11 +90,7 @@
             }
         }
 
-        auto declare_function_param(string_ref name, mlir_value value) {
-            return symbols.vars.insert(name, value), value;
-        }
-
-        mlir_value lookup_var(string_ref name) const {
+        operation lookup_var(string_ref name) const {
             return symbols.vars.lookup(name);
         }
 
@@ -190,8 +186,7 @@
 
         virtual ~block_scope() = default;
 
-        symbol_table_scope< string_ref, mlir_value > vars;
-
+        symbol_table_scope< string_ref, operation > vars;
         symbol_table_scope< string_ref, operation > types;
         symbol_table_scope< string_ref, operation > enum_constants;
     };
@@ -239,7 +234,7 @@
 
         symbol_table_scope< string_ref, operation >  functions;
         symbol_table_scope< string_ref, operation >  types;
-        symbol_table_scope< string_ref, mlir_value > globals;
+        symbol_table_scope< string_ref, operation > globals;
         symbol_table_scope< string_ref, operation >  enum_constants;
     };
 

include/vast/Conversion/Common/Mixins.hpp

@@ -1,4 +1,4 @@
 // Copyright (c) 2022-present, Trail of Bits, Inc.
 
 #pragma once
 
@@ -82,6 +82,25 @@
         }
     };
 
+
+    template< typename type_converter >
+    struct type_converting_conversion_config : base_conversion_config {
+        type_converter &tc;
+
+        type_converting_conversion_config(
+            rewrite_pattern_set patterns,
+            conversion_target target,
+            type_converter &tc
+        )
+            : base_conversion_config{std::move(patterns), std::move(target)}, tc(tc)
+        {}
+
+        template< typename pattern >
+        void add_pattern() {
+            patterns.template add< pattern >(tc, patterns.getContext());
+        }
+    };
+
     // Configuration class for LLVM conversion
     using llvm_type_converter = conv::tc::FullLLVMTypeConverter;
 
@@ -110,7 +129,7 @@
     // base class for module conversion passes providing common functionality
     //
     template< typename derived, template< typename > typename base >
-    struct ModuleConversionPassMixinBase
+    struct ConversionPassMixinBase
         : base< derived >
         , populate_patterns< derived >
     {
@@ -165,8 +184,8 @@
     //
     // Example usage:
     //
-    // struct ExamplePass : ModuleConversionPassMixin<ExamplePass, ExamplePassBase> {
-    //     using base = ModuleConversionPassMixin<ExamplePass, ExamplePassBase>;
+    // struct ExamplePass : ConversionPassMixin<ExamplePass, ExamplePassBase> {
+    //     using base = ConversionPassMixin<ExamplePass, ExamplePassBase>;
     //
     //     static conversion_target create_conversion_target(mcontext_t &context) {
     //         conversion_target target(context);
@@ -182,22 +201,34 @@
     // }
     //
     template< typename derived, template< typename > typename base >
-    struct ModuleConversionPassMixin : ModuleConversionPassMixinBase< derived, base >
+    struct ConversionPassMixin : ConversionPassMixinBase< derived, base >
     {
         base_conversion_config make_config() {
             auto &ctx = this->getContext();
             return { rewrite_pattern_set(&ctx), derived::create_conversion_target(ctx) };
         }
     };
 
+    template< typename derived, template< typename > typename base, typename type_converter >
+    struct TypeConvertingConversionPassMixin : ConversionPassMixinBase< derived, base >
+    {
+        std::shared_ptr< type_converter > tc;
+
+        type_converting_conversion_config< type_converter > make_config() {
+            auto &ctx = this->getContext();
+            tc = std::make_shared< type_converter >(ctx);
+            return { rewrite_pattern_set(&ctx), derived::create_conversion_target(ctx), *tc };
+        }
+    };
+
     //
     // Mixin for conversion passes that target the LLVM dialect.
     // Requires the derived pass to specify LLVM-specific conversion logic.
     //
     // Example usage:
     //
-    // struct ExamplePass : ModuleLLVMConversionPassMixin<ExamplePass, ExamplePassBase> {
-    //     using base = ModuleLLVMConversionPassMixin<ExamplePass, ExamplePassBase>;
+    // struct ExamplePass : LLVMConversionPassMixin<ExamplePass, ExamplePassBase> {
+    //     using base = LLVMConversionPassMixin<ExamplePass, ExamplePassBase>;
     //
     //     static conversion_target create_conversion_target(mcontest_t &context) {
     //         conversion_target target(context);
@@ -213,8 +244,8 @@
     // }
     //
     template< typename derived, template< typename > typename base >
-    struct ModuleLLVMConversionPassMixin
-        : ModuleConversionPassMixinBase< derived, base >
+    struct LLVMConversionPassMixin
+        : ConversionPassMixinBase< derived, base >
     {
         std::shared_ptr< llvm_type_converter > tc;
 

include/vast/Conversion/Common/Patterns.hpp

@@ -97,6 +97,9 @@ namespace vast {
 
         generic_conversion_pattern(mlir::TypeConverter &tc, mcontext_t &mctx)
             : base(tc, mlir::Pattern::MatchAnyOpTypeTag{}, 1, &mctx) {}
+
+        generic_conversion_pattern(mlir::TypeConverter &tc, mcontext_t *mctx)
+            : base(tc, mlir::Pattern::MatchAnyOpTypeTag{}, 1, mctx) {}
     };
 
     template< typename op_t >

include/vast/Conversion/Passes.hpp

@@ -1,4 +1,4 @@
 // Copyright (c) 2022-present, Trail of Bits, Inc.
 
 #pragma once
 
@@ -51,18 +51,21 @@
 
     std::unique_ptr< mlir::Pass > createHLToLLGEPsPass();
 
-    std::unique_ptr< mlir::Pass > createHLToLLVarsPass();
-
     std::unique_ptr< mlir::Pass > createHLEmitLazyRegionsPass();
 
     std::unique_ptr< mlir::Pass > createHLToLLFuncPass();
 
     std::unique_ptr< mlir::Pass > createHLToHLBI();
 
-    std::unique_ptr< mlir::Pass > createFnArgsToAllocaPass();
-
     std::unique_ptr< mlir::Pass > createLowerValueCategoriesPass();
 
+    // ToMem
+    std::unique_ptr< mlir::Pass > createRefsToSSAPass();
+
+    std::unique_ptr< mlir::Pass > createStripParamLValuesPass();
+
+    std::unique_ptr< mlir::Pass > createVarsToCellsPass();
+
     // Generate the code for registering passes.
     #define GEN_PASS_REGISTRATION
     #include "vast/Conversion/Passes.h.inc"
@@ -76,6 +79,8 @@
 
         pipeline_step_ptr to_ll();
 
+        pipeline_step_ptr to_mem();
+
         pipeline_step_ptr to_llvm();
 
         pipeline_step_ptr canonicalize();

include/vast/Conversion/Passes.td

@@ -65,20 +65,39 @@ def IRsToLLVM : Pass<"vast-irs-to-llvm", "mlir::ModuleOp"> {
   ];
 }
 
-def FnArgsToAlloca : Pass<"vast-fn-args-to-alloca", "core::ModuleOp"> {
-  let summary = "VAST to LLVM Dialect conversion";
-  let description = [{
-    For each function emit its prologue - for each argument make an alloca
-    and store the corresponding argument in it.
-  }];
+def RefsToSSA : Pass<"vast-refs-to-ssa", "core::ModuleOp"> {
+  let summary = "Lower `hl.ref` into ssa-based `ll.cell`.";
+  let description = [{ TBD }];
 
-  let constructor = "vast::createFnArgsToAllocaPass()";
+  let constructor = "vast::createRefsToSSAPass()";
   let dependentDialects = [
     "vast::ll::LowLevelDialect",
-    "vast::core::CoreDialect"
+    "vast::hl::HighLevelDialect",
+  ];
+}
+
+def StripParamLValues : Pass<"vast-strip-param-lvalues", "core::ModuleOp"> {
+  let summary = "Strip `hl.lvalue` from types in the module.";
+  let description = [{ TBD }];
+
+  let constructor = "vast::createStripParamLValuesPass()";
+  let dependentDialects = [
+    "vast::hl::HighLevelDialect",
+  ];
+}
+
+def VarsToCells : Pass<"vast-vars-to-cells", "core::ModuleOp"> {
+  let summary = "Lower `hl.var` into ssa-based `ll.cell`.";
+  let description = [{ TBD }];
+
+  let constructor = "vast::createVarsToCellsPass()";
+  let dependentDialects = [
+    "vast::ll::LowLevelDialect",
+    "vast::hl::HighLevelDialect",
   ];
 }
 
+
 def LowerValueCategories : Pass<"vast-lower-value-categories", "core::ModuleOp"> {
   let summary = "Lower `hl.lvalue` into explicit pointers and loads.";
   let description = [{
@@ -146,20 +165,6 @@ def HLToLLGEPs : Pass<"vast-hl-to-ll-geps", "core::ModuleOp"> {
   ];
 }
 
-def HLToLLVars : Pass<"vast-hl-to-ll-vars", "core::ModuleOp"> {
-  let summary = "Convert hl variables into ll versions.";
-  let description = [{
-    This pass is still a work in progress.
-  }];
-
-  let constructor = "vast::createHLToLLVarsPass()";
-  let dependentDialects = [
-    "mlir::LLVM::LLVMDialect",
-    "vast::ll::LowLevelDialect",
-    "vast::core::CoreDialect"
-  ];
-}
-
 def HLToLLFunc : Pass<"vast-hl-to-ll-func", "core::ModuleOp"> {
   let summary = "Convert hl functions into ll versions.";
   let description = [{