[MooreToCore] Add support to lower ClassNewOp to llvm.malloc

- Add `getOrCreateMalloc` to declare `llvm.func @malloc(i64) -> !llvm.ptr` (opaque ptr).
- Implement `ClassNewOpConversion`:
  - Resolve class struct body, compute size via `DataLayout`, call `malloc`.
  - Replace `moore.class.new` with result of `malloc` (no cast in opaque-ptr mode).
- Make base-class struct resolution lazy:
  - If a base’s struct isn’t finalized, resolve it on demand.
  - Add overload `resolveClassStructBody(ModuleOp, SymbolRefAttr, ...)`.
- Register new conversion pattern in `populateOpConversion`.

Author: Scheremo

lib/Conversion/MooreToCore/MooreToCore.cpp

@@ -100,6 +100,23 @@ struct ClassTypeCache {
   llvm::DenseMap<mlir::Attribute, ClassStructInfo> classToStructMap;
 };
 
+/// Ensure we have `declare i8* @malloc(i64)` (opaque ptr prints as !llvm.ptr).
+static LLVM::LLVMFuncOp getOrCreateMalloc(ModuleOp mod, OpBuilder &b) {
+  if (auto f = mod.lookupSymbol<LLVM::LLVMFuncOp>("malloc"))
+    return f;
+
+  OpBuilder::InsertionGuard g(b);
+  b.setInsertionPointToStart(mod.getBody());
+
+  auto i64Ty = IntegerType::get(mod.getContext(), 64);
+  auto ptrTy = LLVM::LLVMPointerType::get(mod.getContext()); // opaque pointer
+  auto fnTy = LLVM::LLVMFunctionType::get(ptrTy, {i64Ty}, /*isVarArg=*/false);
+
+  auto fn = LLVM::LLVMFuncOp::create(b, mod.getLoc(), "malloc", fnTy);
+  fn.setLinkage(LLVM::Linkage::External);
+  return fn;
+}
+
 /// Helper function to create an LLVM-friendly name from a class name symbol
 /// Classname is expected to be in a H1::H2::H3::@C format.
 static std::string mangleClassName(SymbolRefAttr className) {
@@ -150,12 +167,13 @@ static LogicalResult resolveClassStructBody(circt::moore::ClassDeclOp op,
 
   if (auto baseClass = op.getBaseAttr()) {
 
+    ModuleOp mod = op->getParentOfType<ModuleOp>();
+    auto classDeclOp = cast<moore::ClassDeclOp>(*mod.lookupSymbol(baseClass));
+    if (failed(resolveClassStructBody(classDeclOp, typeConverter, cache)))
+      op.emitError() << "Failed to convert base class " << baseClass;
+
     // Process base class' struct layout first
     auto baseClassStruct = cache.getStructInfo(baseClass);
-    if (!baseClassStruct || !baseClassStruct->isFinalized)
-      return op.emitOpError() << "Base class " << baseClass << " of "
-                              << classSym << " has not been converted.";
-
     structBodyMembers.push_back(baseClassStruct->classBody);
     derivedStartIdx = 1;
 
@@ -200,6 +218,14 @@ static LogicalResult resolveClassStructBody(circt::moore::ClassDeclOp op,
   return success();
 }
 
+/// Convenience overload if
+static LogicalResult resolveClassStructBody(ModuleOp mod, SymbolRefAttr op,
+                                            TypeConverter const &typeConverter,
+                                            ClassTypeCache &cache) {
+  auto classDeclOp = cast<moore::ClassDeclOp>(*mod.lookupSymbol(op));
+  return resolveClassStructBody(classDeclOp, typeConverter, cache);
+}
+
 /// Returns the passed value if the integer width is already correct.
 /// Zero-extends if it is too narrow.
 /// Truncates if the integer is too wide and the truncated part is zero, if it
@@ -701,6 +727,52 @@ static Value createZeroValue(Type type, Location loc,
   return rewriter.createOrFold<hw::BitcastOp>(loc, type, constZero);
 }
 
+/// moore.class.new lowering: heap-allocate storage for the class object.
+struct ClassNewOpConversion : public OpConversionPattern<ClassNewOp> {
+  ClassNewOpConversion(TypeConverter &tc, MLIRContext *ctx,
+                       ClassTypeCache &cache)
+      : OpConversionPattern<ClassNewOp>(tc, ctx), cache(cache) {}
+
+  LogicalResult
+  matchAndRewrite(ClassNewOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    Location loc = op.getLoc();
+    MLIRContext *ctx = rewriter.getContext();
+
+    auto handleTy = cast<ClassHandleType>(op.getResult().getType());
+    auto sym = handleTy.getClassSym();
+
+    ModuleOp mod = op->getParentOfType<ModuleOp>();
+
+    if (failed(resolveClassStructBody(mod, sym, *typeConverter, cache)))
+      return op.emitError() << "Could not resolve class struct for " << sym;
+
+    auto structTy = cache.getStructInfo(sym)->classBody;
+
+    DataLayout dl(mod);
+    // DataLayout::getTypeSize gives a byte count for LLVM types.
+    uint64_t byteSize = dl.getTypeSize(structTy);
+    auto i64Ty = IntegerType::get(ctx, 64);
+    auto cSize = LLVM::ConstantOp::create(rewriter, loc, i64Ty,
+                                          rewriter.getI64IntegerAttr(byteSize));
+
+    // Get or declare malloc and call it.
+    auto mallocFn = getOrCreateMalloc(mod, rewriter);
+    auto ptrTy = LLVM::LLVMPointerType::get(ctx); // opaque pointer result
+    auto call =
+        LLVM::CallOp::create(rewriter, loc, TypeRange{ptrTy},
+                             SymbolRefAttr::get(mallocFn), ValueRange{cSize});
+
+    // Replace the new op with the malloc pointer (no cast needed with opaque
+    // ptrs).
+    rewriter.replaceOp(op, call.getResult());
+    return success();
+  }
+
+private:
+  ClassTypeCache &cache; // shared, owned by the pass
+};
+
 struct ClassDeclOpConversion : public OpConversionPattern<ClassDeclOp> {
   ClassDeclOpConversion(TypeConverter &tc, MLIRContext *ctx,
                         ClassTypeCache &cache)
@@ -709,9 +781,9 @@ struct ClassDeclOpConversion : public OpConversionPattern<ClassDeclOp> {
   LogicalResult
   matchAndRewrite(ClassDeclOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
+
     if (failed(resolveClassStructBody(op, *typeConverter, cache)))
       return failure();
-
     // The declaration itself is a no-op
     rewriter.eraseOp(op);
     return success();
@@ -2118,7 +2190,8 @@ static void populateOpConversion(ConversionPatternSet &patterns,
 
   patterns.add<ClassDeclOpConversion>(typeConverter, patterns.getContext(),
                                       classCache);
-
+  patterns.add<ClassNewOpConversion>(typeConverter, patterns.getContext(),
+                                     classCache);
   // clang-format off
   patterns.add<
     // Patterns of declaration operations.

test/Conversion/MooreToCore/classes.mlir

@@ -28,3 +28,88 @@ module {
          : !llvm.struct<"moore.class.PropertyCombo", (i32, i18, i32)>
   }
 }
+
+/// Check that new lowers to malloc
+
+// malloc should be declared in the LLVM dialect.
+// CHECK: llvm.func @malloc(i64) -> !llvm.ptr
+// CHECK: func.func private @test_new2
+// CHECK:   [[SIZE:%.*]] = llvm.mlir.constant(12 : i64) : i64
+// CHECK:   [[PTR:%.*]] = llvm.call @malloc([[SIZE]]) : (i64) -> !llvm.ptr
+// CHECK:   return
+
+// Original op must be gone.
+// CHECK-NOT: moore.class.new
+
+// Class decl should be erased by the class lowering pass.
+// CHECK-NOT: moore.class.classdecl
+
+module {
+  // Allocate a new instance; should lower to llvm.call @malloc(i64).
+  func.func private @test_new2() {
+    %h = moore.class.new : <@C>
+    return
+  }
+  // Minimal class so the identified struct has a concrete body.
+  moore.class.classdecl @C {
+    moore.class.propertydecl @a : !moore.i32
+    moore.class.propertydecl @b : !moore.l32
+    moore.class.propertydecl @c : !moore.l32
+  }
+}
+
+/// Check that new lowers to malloc with inheritance without shadowing
+
+// CHECK-LABEL: func.func private @test_new3
+// CHECK:   [[SIZE:%.*]] = llvm.mlir.constant(28 : i64) : i64
+// CHECK:   [[PTR:%.*]] = llvm.call @malloc([[SIZE]]) : (i64) -> !llvm.ptr
+// CHECK:   return
+
+// CHECK-NOT: moore.class.new
+// CHECK-NOT: moore.class.classdecl
+
+module {
+  func.func private @test_new3() {
+    %h = moore.class.new : <@D>
+    return
+  }
+  moore.class.classdecl @C {
+    moore.class.propertydecl @a : !moore.i32
+    moore.class.propertydecl @b : !moore.l32
+    moore.class.propertydecl @c : !moore.l32
+  }
+  moore.class.classdecl @D extends @C {
+    moore.class.propertydecl @d : !moore.l32
+    moore.class.propertydecl @e : !moore.l64
+    moore.class.propertydecl @f : !moore.i16
+  }
+
+}
+
+/// Check that new lowers to malloc with inheritance & shadowing
+
+// CHECK-LABEL: func.func private @test_new4
+// CHECK:   [[SIZE:%.*]] = llvm.mlir.constant(24 : i64) : i64
+// CHECK:   [[PTR:%.*]] = llvm.call @malloc([[SIZE]]) : (i64) -> !llvm.ptr
+// CHECK:   return
+
+// CHECK-NOT: moore.class.new
+// CHECK-NOT: moore.class.classdecl
+
+module {
+  func.func private @test_new4() {
+    %h = moore.class.new : <@E>
+    return
+  }
+  moore.class.classdecl @C {
+    moore.class.propertydecl @a : !moore.i32
+    moore.class.propertydecl @b : !moore.l32
+    moore.class.propertydecl @c : !moore.l32
+  }
+  moore.class.classdecl @E extends @C {
+    moore.class.propertydecl @a : !moore.i32
+    moore.class.propertydecl @b : !moore.l32
+    moore.class.propertydecl @c : !moore.l32
+  }
+
+}