Mlir backend improvements

.github/workflows/premerge.yml

@@ -22,8 +22,8 @@ jobs:
       run: |
         wget https://apt.llvm.org/llvm.sh
         chmod +x llvm.sh
-        sudo ./llvm.sh 20
-        sudo apt install libmlir-20-dev mlir-20-tools
+        sudo ./llvm.sh 23
+        sudo apt install libmlir-23-dev mlir-23-tools
 
     - name: ccache
       uses: hendrikmuhs/ccache-action@v1.2

CMakePresets.json

@@ -20,6 +20,16 @@
         "CMAKE_BUILD_TYPE": "Release",
         "CPM_SOURCE_CACHE": ".cache/CPM"
       }
+    },
+    {
+      "name": "release-with-debug-info",
+      "displayName": "Release with Debug Info",
+      "generator": "Ninja",
+      "binaryDir": "build/release-with-debug-info",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo",
+        "CPM_SOURCE_CACHE": ".cache/CPM"
+      }
     }
   ],
   "buildPresets": [
@@ -34,6 +44,12 @@
       "displayName": "Release Build",
       "configurePreset": "release",
       "configuration": "Release"
+    },
+    {
+      "name": "release-with-debug-info",
+      "displayName": "Release with Debug Info Build",
+      "configurePreset": "release-with-debug-info",
+      "configuration": "RelWithDebInfo"
     }
   ],
   "testPresets": [
@@ -46,6 +62,11 @@
       "name": "release",
       "displayName": "Test all in Release mode",
       "configurePreset": "release"
+    },
+    {
+      "name": "release-with-debug-info",
+      "displayName": "Test all in Release with Debug Info mode",
+      "configurePreset": "release-with-debug-info"
     }
   ]
 

src/CMakeLists.txt

@@ -298,7 +298,7 @@ target_link_libraries(python-cpp
 )
 
 # LLVM backend
-find_package(LLVM CONFIG 20.1)
+find_package(LLVM CONFIG 23)
 if(ENABLE_LLVM_BACKEND AND NOT LLVM_FOUND)
   message(FATAL_ERROR "Could not find LLVM in the local environment")
 elseif(ENABLE_LLVM_BACKEND AND LLVM_FOUND)

src/executable/bytecode/Bytecode.cpp

@@ -132,7 +132,9 @@ py::PyResult<py::Value> Bytecode::eval_loop(VirtualMachine &vm, Interpreter &int
 		ASSERT((*vm.instruction_pointer()).get());
 		const auto &current_ip = vm.instruction_pointer();
 		const auto &instruction = *current_ip;
-		spdlog::debug("{} {}", (void *)instruction.get(), instruction->to_string());
+		// spdlog::debug("{} {}", (void *)instruction.get(), instruction->to_string());
+		// std::cout << std::format("{} {}", (void *)instruction.get(), instruction->to_string())
+		// 		  << std::endl;
 		auto result = instruction->execute(vm, vm.interpreter());
 		// we left the current stack frame in the previous instruction
 		if (vm.stack().size() != stack_depth) {

src/executable/bytecode/instructions/ListToTuple.cpp

@@ -1,8 +1,11 @@
 #include "ListToTuple.hpp"
 #include "runtime/PyList.hpp"
+#include "runtime/PyString.hpp"
 #include "runtime/PyTuple.hpp"
 #include "vm/VM.hpp"
 
+#include <iostream>
+
 using namespace py;
 
 PyResult<Value> ListToTuple::execute(VirtualMachine &vm, Interpreter &) const
@@ -12,6 +15,14 @@ PyResult<Value> ListToTuple::execute(VirtualMachine &vm, Interpreter &) const
 	ASSERT(std::holds_alternative<PyObject *>(list));
 
 	auto *pylist = std::get<PyObject *>(list);
+	if (!as<PyList>(pylist)) {
+		std::cout << to_string() << std::endl;
+		if (!pylist) {
+			std::cout << "(null)" << std::endl;
+		} else {
+			std::cout << pylist->str().unwrap()->to_string() << std::endl;
+		}
+	}
 	ASSERT(as<PyList>(pylist));
 
 	auto result = PyTuple::create(as<PyList>(pylist)->elements());

src/executable/bytecode/instructions/YieldFrom.cpp

@@ -49,7 +49,7 @@ PyResult<Value> YieldFrom::execute(VirtualMachine &vm, Interpreter &interpreter)
 		vm.reg(m_dst) = result.unwrap();
 		vm.reg(0) = result.unwrap();
 		vm.set_instruction_pointer(vm.instruction_pointer() - 1);
-		vm.pop_frame(true);
+		vm.pop_frame(false);
 	}
 
 	return result;

src/executable/bytecode/instructions/YieldValue.cpp

@@ -23,7 +23,7 @@ PyResult<Value> YieldValue::execute(VirtualMachine &vm, Interpreter &interpreter
 
 	vm.reg(0) = result;
 
-	vm.pop_frame(true);
+	vm.pop_frame(false);
 
 	return Ok(result);
 }

src/executable/bytecode/serialization/deserialize.hpp

@@ -5,6 +5,7 @@
 #include "serialize.hpp"
 #include "utilities.hpp"
 
+#include <iostream>
 #include <span>
 #include <string>
 

src/executable/mlir/CMakeLists.txt

@@ -1,4 +1,4 @@
-find_package(LLVM 20.1 REQUIRED CONFIG)
+find_package(LLVM 23 REQUIRED CONFIG)
 message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 
 find_package(MLIR CONFIG REQUIRED
@@ -20,6 +20,8 @@ set(PYTHON_MLIR_BINARY_DIR ${PROJECT_BINARY_DIR}/src/executable/mlir)
 add_subdirectory(Conversion)
 add_subdirectory(Dialect)
 add_subdirectory(Target)
+add_subdirectory(tools/python-mlir-opt)
+add_subdirectory(test)
 
 add_library(python-mlir compile.cpp)
 target_link_libraries(python-mlir PRIVATE PythonMLIRDialect TargetPythonBytecode PythonConversionPasses)

src/executable/mlir/Conversion/Passes.td

@@ -4,4 +4,30 @@ include "mlir/Pass/PassBase.td"
 def ConvertPythonToPythonBytecode : Pass<"convert-python-to-pythonbytecode"> {
   let summary = "Convert recognized Python ops to PythonCpp bytecode";
   let constructor = "mlir::py::createPythonToPythonBytecodePass()";
+}
+
+def ConvertPyForLoop : Pass<"convert-py-forloop"> {
+  let summary = "Lower py.for_loop to emitpybytecode control flow";
+  let constructor = "mlir::py::createConvertForLoopPass()";
+}
+
+def ConvertPyWhile : Pass<"convert-py-while"> {
+  let summary = "Lower py.while to emitpybytecode control flow";
+  let constructor = "mlir::py::createConvertWhileLoopPass()";
+}
+
+def ConvertPyTry : Pass<"convert-py-try"> {
+  let summary = "Lower py.try (and its handler scopes) to emitpybytecode control flow";
+  let constructor = "mlir::py::createConvertTryPass()";
+}
+
+def ConvertPyWith : Pass<"convert-py-with"> {
+  let summary = "Lower py.with to emitpybytecode control flow";
+  let constructor = "mlir::py::createConvertWithPass()";
+}
+
+def MaterialiseReturnNone : Pass<"materialise-return-none", "::mlir::func::FuncOp"> {
+  let summary = "Insert emitpybytecode.LOAD_CONST(None) before zero-operand func.return ops";
+  let constructor = "mlir::py::createMaterialiseReturnNonePass()";
+  let dependentDialects = ["::mlir::emitpybytecode::EmitPythonBytecodeDialect"];
 }

src/executable/mlir/Conversion/PythonToPythonBytecode/ArithPatterns.cpp

@@ -0,0 +1,147 @@
+#include "Conversion/PythonToPythonBytecode/LoweringHelpers.hpp"
+#include "Conversion/PythonToPythonBytecode/PatternPopulators.hpp"
+
+#include "Dialect/EmitPythonBytecode/IR/EmitPythonBytecode.hpp"
+#include "Dialect/Python/IR/PythonOps.hpp"
+
+#include "executable/bytecode/instructions/BinaryOperation.hpp"
+#include "executable/bytecode/instructions/Unary.hpp"
+#include "utilities.hpp"
+
+#include "mlir/IR/PatternMatch.h"
+
+namespace mlir::py {
+namespace {
+
+	// Translate py.{binary,inplace_op}'s ArithOpKind enum to the
+	// bytecode-level BinaryOperation::Operation enum. The two are
+	// deliberately decoupled: the dialect enum is part of the IR
+	// contract; the bytecode enum is the wire format consumed by the
+	// VM, so the mapping between the two must stay explicit.
+	BinaryOperation::Operation py_kind_to_binary_op(mlir::py::ArithOpKind kind)
+	{
+		switch (kind) {
+		case mlir::py::ArithOpKind::add:
+			return BinaryOperation::Operation::PLUS;
+		case mlir::py::ArithOpKind::sub:
+			return BinaryOperation::Operation::MINUS;
+		case mlir::py::ArithOpKind::mod:
+			return BinaryOperation::Operation::MODULO;
+		case mlir::py::ArithOpKind::mul:
+			return BinaryOperation::Operation::MULTIPLY;
+		case mlir::py::ArithOpKind::exp:
+			return BinaryOperation::Operation::EXP;
+		case mlir::py::ArithOpKind::div:
+			return BinaryOperation::Operation::SLASH;
+		case mlir::py::ArithOpKind::fldiv:
+			return BinaryOperation::Operation::FLOORDIV;
+		case mlir::py::ArithOpKind::mmul:
+			return BinaryOperation::Operation::MATMUL;
+		case mlir::py::ArithOpKind::lshift:
+			return BinaryOperation::Operation::LEFTSHIFT;
+		case mlir::py::ArithOpKind::rshift:
+			return BinaryOperation::Operation::RIGHTSHIFT;
+		case mlir::py::ArithOpKind::and_:
+			return BinaryOperation::Operation::AND;
+		case mlir::py::ArithOpKind::or_:
+			return BinaryOperation::Operation::OR;
+		case mlir::py::ArithOpKind::xor_:
+			return BinaryOperation::Operation::XOR;
+		}
+		ASSERT_NOT_REACHED();
+	}
+
+	struct InplaceOpLowering : public mlir::OpRewritePattern<InplaceOp>
+	{
+		using OpRewritePattern<InplaceOp>::OpRewritePattern;
+
+		mlir::LogicalResult matchAndRewrite(InplaceOp op,
+			mlir::PatternRewriter &rewriter) const final
+		{
+			auto op_type = mlir::IntegerAttr::get(rewriter.getIntegerType(8, false),
+				static_cast<uint8_t>(py_kind_to_binary_op(op.getKind())));
+
+			rewriter.replaceOpWithNewOp<mlir::emitpybytecode::InplaceOp>(
+				op, op.getResult().getType(), op.getDst(), op.getSrc(), op_type);
+
+			return success();
+		}
+	};
+
+	struct BinaryOpLowering : public mlir::OpRewritePattern<mlir::py::BinaryOp>
+	{
+		using OpRewritePattern<mlir::py::BinaryOp>::OpRewritePattern;
+
+		mlir::LogicalResult matchAndRewrite(mlir::py::BinaryOp op,
+			mlir::PatternRewriter &rewriter) const final
+		{
+			auto op_type = mlir::IntegerAttr::get(rewriter.getIntegerType(8, false),
+				static_cast<uint8_t>(py_kind_to_binary_op(op.getKind())));
+			rewriter.replaceOpWithNewOp<mlir::emitpybytecode::BinaryOp>(
+				op, op.getOutput().getType(), op.getLhs(), op.getRhs(), op_type);
+			return success();
+		}
+	};
+
+	// Trivial 1:1 lowering of a py.unary_* op to emitpybytecode.UNARY_OP
+	// with the corresponding Unary::Operation enum baked in.
+	template<typename From, Unary::Operation Kind>
+	struct UnaryOpLowering : public mlir::OpRewritePattern<From>
+	{
+		using mlir::OpRewritePattern<From>::OpRewritePattern;
+
+		mlir::LogicalResult matchAndRewrite(From op, mlir::PatternRewriter &rewriter) const final
+		{
+			rewriter.template replaceOpWithNewOp<mlir::emitpybytecode::UnaryOp>(
+				op, op.getOutput().getType(), op.getInput(), static_cast<uint8_t>(Kind));
+			return mlir::success();
+		}
+	};
+
+	using PositiveOpLowering = UnaryOpLowering<mlir::py::PositiveOp, Unary::Operation::POSITIVE>;
+	using NegativeOpLowering = UnaryOpLowering<mlir::py::NegativeOp, Unary::Operation::NEGATIVE>;
+	using InvertOpLowering = UnaryOpLowering<mlir::py::InvertOp, Unary::Operation::INVERT>;
+	using NotOpLowering = UnaryOpLowering<mlir::py::NotOp, Unary::Operation::NOT>;
+
+	struct CompareOpLowering : public mlir::OpRewritePattern<mlir::py::CompareOp>
+	{
+		using OpRewritePattern<mlir::py::CompareOp>::OpRewritePattern;
+
+		mlir::LogicalResult matchAndRewrite(mlir::py::CompareOp op,
+			mlir::PatternRewriter &rewriter) const final
+		{
+			auto lhs = op.getLhs();
+			auto rhs = op.getRhs();
+			auto op_type = mlir::IntegerAttr::get(
+				rewriter.getIntegerType(8, false), static_cast<uint8_t>(op.getPredicate()));
+
+			rewriter.replaceOpWithNewOp<mlir::emitpybytecode::Compare>(
+				op, op.getOutput().getType(), lhs, rhs, op_type);
+
+			return success();
+		}
+	};
+
+	struct CastToBoolOpLowering : public mlir::OpRewritePattern<mlir::py::CastToBoolOp>
+	{
+		using OpRewritePattern<mlir::py::CastToBoolOp>::OpRewritePattern;
+
+		mlir::LogicalResult matchAndRewrite(mlir::py::CastToBoolOp op,
+			mlir::PatternRewriter &rewriter) const final
+		{
+			rewriter.replaceOpWithNewOp<mlir::emitpybytecode::CastToBool>(
+				op, op.getValue().getType(), op.getValue());
+			return success();
+		}
+	};
+
+}// namespace
+
+void populateArithPatterns(mlir::RewritePatternSet &patterns)
+{
+	auto *ctx = patterns.getContext();
+	patterns.add<BinaryOpLowering, InplaceOpLowering, CompareOpLowering, CastToBoolOpLowering>(ctx);
+	patterns.add<PositiveOpLowering, NegativeOpLowering, InvertOpLowering, NotOpLowering>(ctx);
+}
+
+}// namespace mlir::py

src/executable/mlir/Conversion/PythonToPythonBytecode/AttributeSubscriptPatterns.cpp

@@ -0,0 +1,49 @@
+#include "Conversion/PythonToPythonBytecode/LoweringHelpers.hpp"
+#include "Conversion/PythonToPythonBytecode/PatternPopulators.hpp"
+
+#include "Dialect/EmitPythonBytecode/IR/EmitPythonBytecode.hpp"
+#include "Dialect/Python/IR/PythonOps.hpp"
+
+#include "mlir/IR/PatternMatch.h"
+
+namespace mlir::py {
+namespace {
+
+	using LoadAttributeOpLowering = detail::DirectReplaceLowering<mlir::py::LoadAttributeOp,
+		mlir::emitpybytecode::LoadAttribute>;
+
+	using DeleteAttributeOpLowering = detail::DirectReplaceLowering<mlir::py::DeleteAttributeOp,
+		mlir::emitpybytecode::DeleteAttribute>;
+
+	using LoadMethodOpLowering = detail::DirectReplaceRegisterName<mlir::py::LoadMethodOp,
+		mlir::emitpybytecode::LoadMethod,
+		&mlir::py::LoadMethodOp::getMethodName>;
+
+	using BinarySubscriptOpLowering = detail::DirectReplaceLowering<mlir::py::BinarySubscriptOp,
+		mlir::emitpybytecode::BinarySubscript>;
+
+	using StoreSubscriptOpLowering = detail::DirectReplaceLowering<mlir::py::StoreSubscriptOp,
+		mlir::emitpybytecode::StoreSubscript>;
+
+	using DeleteSubscriptOpLowering = detail::DirectReplaceLowering<mlir::py::DeleteSubscriptOp,
+		mlir::emitpybytecode::DeleteSubscript>;
+
+	using StoreAttributeOpLowering = detail::DirectReplaceRegisterName<mlir::py::StoreAttributeOp,
+		mlir::emitpybytecode::StoreAttribute,
+		&mlir::py::StoreAttributeOp::getAttr>;
+
+}// namespace
+
+void populateAttributeSubscriptPatterns(mlir::RewritePatternSet &patterns)
+{
+	auto *ctx = patterns.getContext();
+	patterns.add<LoadAttributeOpLowering,
+		DeleteAttributeOpLowering,
+		LoadMethodOpLowering,
+		BinarySubscriptOpLowering,
+		StoreSubscriptOpLowering,
+		DeleteSubscriptOpLowering,
+		StoreAttributeOpLowering>(ctx);
+}
+
+}// namespace mlir::py

src/executable/mlir/Conversion/PythonToPythonBytecode/CMakeLists.txt

@@ -1,5 +1,12 @@
 add_mlir_conversion_library(PythonToPythonBytecode
     PythonToPythonBytecode.cpp
+    ArithPatterns.cpp
+    AttributeSubscriptPatterns.cpp
+    CollectionPatterns.cpp
+    ControlFlowPatterns.cpp
+    FunctionPatterns.cpp
+    ImportPatterns.cpp
+    LoadStorePatterns.cpp
 
     ADDITIONAL_HEADER_DIRS
     ${PROJECT_SOURCE_DIR}/src/executable/mlir/Conversion/PythonToPythonBytecode