Obliterate hl-structs-to-llvm conversion pass.

include/vast/Conversion/Common/Passes.hpp

@@ -1,4 +1,4 @@
 // Copyright (c) 2022-present, Trail of Bits, Inc.
 
 #pragma once
 
@@ -223,7 +223,7 @@
             mlir::LowerToLLVMOptions llvm_options{ &ctx };
             derived_t::set_llvm_opts(llvm_options);
 
-            auto tc = llvm_type_converter(&ctx, llvm_options, &dl_analysis);
+            auto tc = llvm_type_converter(getOperation(), &ctx, llvm_options, &dl_analysis);
             auto cfg = config(
                 rewrite_pattern_set(&ctx), derived_t::create_conversion_target(ctx, tc), tc
             );

include/vast/Conversion/Passes.hpp

@@ -51,8 +51,6 @@ namespace vast
 
     std::unique_ptr< mlir::Pass > createHLToLLVarsPass();
 
-    std::unique_ptr< mlir::Pass > createHLStructsToLLVMPass();
-
     std::unique_ptr< mlir::Pass > createHLEmitLazyRegionsPass();
 
     std::unique_ptr< mlir::Pass > createHLToLLFuncPass();
@@ -79,7 +77,6 @@ namespace vast
 
     static inline void build_to_llvm_pipeline(mlir::PassManager &pm)
     {
-        pm.addPass(createHLStructsToLLVMPass());
         pm.addPass(createIRsToLLVMPass());
         pm.addPass(createCoreToLLVMPass());
     }

include/vast/Conversion/Passes.td

@@ -143,19 +143,6 @@ def HLToLLFunc : Pass<"vast-hl-to-ll-func", "mlir::ModuleOp"> {
   ];
 }
 
-def HLStructsToLLVM : Pass<"vast-hl-structs-to-llvm", "mlir::ModuleOp"> {
-  let summary = "Transform hl.struct into llvm types without applying ABI conversions.";
-  let description = [{
-    This pass is still a work in progress.
-  }];
-
-  let constructor = "vast::createHLStructsToLLVMPass()";
-  let dependentDialects = [
-    "mlir::LLVM::LLVMDialect",
-    "vast::core::CoreDialect"
-  ];
-}
-
 def HLEmitLazyRegions : Pass<"vast-hl-to-lazy-regions", "mlir::ModuleOp"> {
   let summary = "Transform hl operations that have short-circuiting into lazy operations.";
   let description = [{

include/vast/Conversion/TypeConverters/LLVMTypeConverter.hpp

@@ -1,4 +1,4 @@
 // Copyright (c) 2022, Trail of Bits, Inc.
 
 #pragma once
 
@@ -10,6 +10,7 @@
 VAST_UNRELAX_WARNINGS
 
 #include "vast/Dialect/HighLevel/HighLevelTypes.hpp"
+#include "vast/Dialect/HighLevel/HighLevelUtils.hpp"
 #include "vast/Util/Maybe.hpp"
 
 #include "vast/Conversion/TypeConverters/TypeConverter.hpp"
@@ -174,16 +175,77 @@
         }
     };
 
+    template< typename self_t >
+    struct LLVMStruct
+    {
+      private:
+        self_t &self() { return static_cast< self_t & >(*this); }
+
+      public:
+        maybe_types_t convert_field_types(mlir_type t) {
+            auto field_types = self().get_field_types(t);
+            if (!field_types)
+                return {};
+
+            mlir::SmallVector< mlir_type, 4 > out;
+            for (auto field_type : *field_types) {
+                auto c = self().convert_type_to_type(field_type);
+                VAST_ASSERT(c);
+                out.push_back(*c);
+            }
+            return { std::move(out) };
+        }
+
+        template< typename op_t >
+        auto convert_recordlike() {
+            // We need this prototype to handle recursive types.
+            return [&](op_t t, mlir::SmallVectorImpl< mlir_type > &out,
+                       mlir::ArrayRef< mlir_type > stack) -> logical_result {
+                auto core = mlir::LLVM::LLVMStructType::getIdentified(
+                    t.getContext(), t.getName());
+                // Last element is `t`.
+                auto bt = stack.drop_back();
+
+                if (core.isOpaque() && std::ranges::find(bt, t) == bt.end()) {
+                    if (auto body = convert_field_types(t)) {
+                        // Multithreading may cause some issues?
+                        auto status = core.setBody(*body, false);
+                        VAST_ASSERT(mlir::succeeded(status));
+                    }
+                }
+                out.push_back(core);
+                return mlir::success();
+            };
+        }
+    };
+
     // Requires that the named types *always* map to llvm struct types.
     // TODO(lukas): What about type aliases.
-    struct FullLLVMTypeConverter : LLVMTypeConverter
+    struct FullLLVMTypeConverter : LLVMTypeConverter,
+                                   LLVMStruct< FullLLVMTypeConverter >
     {
         using base = LLVMTypeConverter;
 
+        vast_module mod;
+
         template< typename... Args >
-        FullLLVMTypeConverter(Args &&...args) : base(std::forward< Args >(args)...) {
-            addConversion([&](hl::RecordType t) { return convert_record_type(t); });
+        FullLLVMTypeConverter(vast_module mod,
+                              Args &&...args)
+        : base(std::forward< Args >(args)...),
+          mod(mod) {
             addConversion([&](hl::ElaboratedType t) { return convert_elaborated_type(t); });
+            addConversion(convert_recordlike< hl::RecordType >());
+        }
+
+        auto get_field_types(mlir_type t) -> std::optional< gap::generator< mlir_type > > {
+            if (!mlir::isa< hl::RecordType >(t))
+                return {};
+            auto def = hl::definition_of(t, mod);
+            // Nothing found, leave the structure opaque.
+            if (!def) {
+                return {};
+            }
+            return { hl::field_types(*def) };
         }
 
         maybe_type_t convert_elaborated_type(hl::ElaboratedType t) {

lib/vast/Conversion/Common/IRsToLLVM.cpp

@@ -1,4 +1,4 @@
 // Copyright (c) 2021-present, Trail of Bits, Inc.
 
 #include "vast/Conversion/Passes.hpp"
 
@@ -42,7 +42,9 @@
 {
     using ignore_patterns = util::type_list<
         ignore_pattern< hl::DeclRefOp >,
-        ignore_pattern< hl::PredefinedExpr >
+        ignore_pattern< hl::PredefinedExpr >,
+        erase_pattern< hl::StructDeclOp >,
+        erase_pattern< hl::TypeDeclOp >
     >;
 
     struct ll_struct_gep : base_pattern< ll::StructGEPOp >
@@ -324,7 +326,7 @@
             for (auto [i, element] : llvm::enumerate(init_list.getElements()))
             {
                 auto e_type = LLVM::LLVMPointerType::get(element.getType());
-                std::vector< mlir::LLVM::GEPArg > indices { 0ul, i + 1 };
+                std::vector< mlir::LLVM::GEPArg > indices { 0ul, i };
 
                 auto gep = rewriter.template create< LLVM::GEPOp >(
                         element.getLoc(), e_type, ptr, indices);

lib/vast/Conversion/FromHL/CMakeLists.txt

@@ -3,7 +3,6 @@
 add_vast_conversion_library(HighLevelConversionPasses
     ToLLCF.cpp
     EmitLazyRegions.cpp
-    StructsToLLVM.cpp
     ToLLGEPs.cpp
     ToLLVars.cpp
     ToLLFunc.cpp

test/vast/Conversion/Common/IRsToLLVM/struct-a.c

@@ -0,0 +1,10 @@
+// RUN: %vast-cc1 -vast-emit-mlir=hl %s -o - | %vast-opt --vast-hl-lower-types --vast-hl-to-ll-cf --vast-hl-to-ll-vars --vast-irs-to-llvm | %file-check %s
+
+struct X { int x; };
+
+int main()
+{
+    // CHECK: {{.*}} = llvm.alloca {{.*}} x !llvm.struct<"X", (i32)> : (i64) -> !llvm.ptr<struct<"X", (i32)>>
+    struct X x;
+    return 0;
+}

test/vast/Conversion/Common/IRsToLLVM/struct-b.c

@@ -0,0 +1,11 @@
+// RUN: %vast-cc1 -vast-emit-mlir=hl %s -o - | %vast-opt --vast-hl-lower-types --vast-hl-to-ll-cf --vast-hl-to-ll-vars --vast-irs-to-llvm | %file-check %s
+
+struct Y;
+struct X { int x; struct Y *y; };
+
+int main()
+{
+    // CHECK: {{.*}} = llvm.alloca {{.*}} x !llvm.struct<"X", (i32, ptr<struct<"Y", opaque>>)> : (i64) -> !llvm.ptr<struct<"X", (i32, ptr<struct<"Y", opaque>>)>>
+    struct X x = { 2, 0 };
+    return 0;
+}

test/vast/Conversion/Common/IRsToLLVM/struct-c.c

@@ -0,0 +1,18 @@
+// RUN: %vast-cc1 -vast-emit-mlir=hl %s -o - | %vast-opt --vast-hl-lower-types --vast-hl-to-ll-cf --vast-hl-to-ll-vars --vast-irs-to-llvm | %file-check %s
+
+struct Y;
+
+struct X { const int x; struct Y *y; };
+
+struct Y { const float x; };
+
+int main()
+{
+    // CHECK: {{.*}}  = llvm.alloca {{.*}} x !llvm.struct<"X", (i32, ptr<struct<"Y", (f32)>>)> : (i64) -> !llvm.ptr<struct<"X", (i32, ptr<struct<"Y", (f32)>>)>>
+    struct X x = { 2, 0 };
+
+    // CHECK: {{.*}} = llvm.alloca {{.*}} x !llvm.struct<"Y", (f32)> : (i64) -> !llvm.ptr<struct<"Y", (f32)>>
+    struct Y y = { 2.0f };
+
+    return 0;
+}