diff --git a/mlir/include/mlir-c/IR.h b/mlir/include/mlir-c/IR.h --- a/mlir/include/mlir-c/IR.h +++ b/mlir/include/mlir-c/IR.h @@ -776,6 +776,13 @@ MLIR_CAPI_EXPORTED void mlirValuePrint(MlirValue value, MlirStringCallback callback, void *userData); +/// Prints a value as an operand (i.e., the ValueID). Note, this isn't +/// canonical (see comment in AsmPrinter::Value::printAsOperand. +MLIR_CAPI_EXPORTED void mlirValuePrintAsOperand(MlirValue value, + bool shouldUseLocalScope, + MlirStringCallback callback, + void *userData); + /// Returns an op operand representing the first use of the value, or a null op /// operand if there are no uses. MLIR_CAPI_EXPORTED MlirOpOperand mlirValueGetFirstUse(MlirValue value); diff --git a/mlir/lib/Bindings/Python/IRCore.cpp b/mlir/lib/Bindings/Python/IRCore.cpp --- a/mlir/lib/Bindings/Python/IRCore.cpp +++ b/mlir/lib/Bindings/Python/IRCore.cpp @@ -156,6 +156,10 @@ equivalent to printing the operation that produced it. )"; +static const char kGetNameAsOperand[] = + R"(Returns the string form of value as an operand (i.e., the ValueID). +)"; + static const char kValueReplaceAllUsesWithDocstring[] = R"(Replace all uses of value with the new value, updating anything in the IR that uses 'self' to use the other value instead. @@ -3336,6 +3340,16 @@ return printAccum.join(); }, kValueDunderStrDocstring) + .def( + "get_name_as_operand", + [](PyValue &self, bool shouldUseLocalScope) { + PyPrintAccumulator printAccum; + mlirValuePrintAsOperand(self.get(), shouldUseLocalScope, + printAccum.getCallback(), + printAccum.getUserData()); + return printAccum.join(); + }, + py::arg("should_use_local_scope") = false, kGetNameAsOperand) .def_property_readonly("type", [](PyValue &self) { return PyType( diff --git a/mlir/lib/CAPI/IR/IR.cpp b/mlir/lib/CAPI/IR/IR.cpp --- a/mlir/lib/CAPI/IR/IR.cpp +++ b/mlir/lib/CAPI/IR/IR.cpp @@ -767,6 +767,41 @@ unwrap(value).print(stream); } +void mlirValuePrintAsOperand(MlirValue value, bool shouldUseLocalScope, + MlirStringCallback callback, void *userData) { + detail::CallbackOstream stream(callback, userData); + + Value cppValue = unwrap(value); + AsmState *state; + Operation *op; + + if (cppValue.isa()) { + op = cppValue.cast().getOwner(); + } else if (cppValue.isa()) { + op = cppValue.cast().getOwner()->getParentOp(); + } else { + stream << "<>"; + return ; + } + + do { + // If we are printing local scope, stop at the first operation that is + // isolated from above. + if (shouldUseLocalScope && op->hasTrait()) + break; + + // Otherwise, traverse up to the next parent. + Operation *parentOp = op->getParentOp(); + if (!parentOp) + break; + op = parentOp; + } while (true); + + state = new AsmState(op); + cppValue.printAsOperand(stream, *state); + delete state; +} + MlirOpOperand mlirValueGetFirstUse(MlirValue value) { Value cppValue = unwrap(value); if (cppValue.use_empty()) diff --git a/mlir/test/python/ir/value.py b/mlir/test/python/ir/value.py --- a/mlir/test/python/ir/value.py +++ b/mlir/test/python/ir/value.py @@ -2,6 +2,7 @@ import gc from mlir.ir import * +from mlir.dialects import func def run(f): @@ -90,6 +91,7 @@ assert hash(block.arguments[0]) == hash(op.operands[0]) assert hash(op.result) == hash(ret.operands[0]) + # CHECK-LABEL: TEST: testValueUses @run def testValueUses(): @@ -112,6 +114,7 @@ print(f"Use owner: {use.owner}") print(f"Use operand_number: {use.operand_number}") + # CHECK-LABEL: TEST: testValueReplaceAllUsesWith @run def testValueReplaceAllUsesWith(): @@ -137,3 +140,95 @@ assert use.owner in [op1, op2] print(f"Use owner: {use.owner}") print(f"Use operand_number: {use.operand_number}") + + +# CHECK-LABEL: TEST: testValuePrintAsOperand +@run +def testValuePrintAsOperand(): + ctx = Context() + ctx.allow_unregistered_dialects = True + with Location.unknown(ctx): + i32 = IntegerType.get_signless(32) + module = Module.create() + with InsertionPoint(module.body): + value = Operation.create("custom.op1", results=[i32]).results[0] + # CHECK: Value(%[[VAL1:.*]] = "custom.op1"() : () -> i32) + print(value) + + value2 = Operation.create("custom.op2", results=[i32]).results[0] + # CHECK: Value(%[[VAL2:.*]] = "custom.op2"() : () -> i32) + print(value2) + + f = func.FuncOp("test", ([i32, i32], [])) + entry_block1 = Block.create_at_start(f.operation.regions[0], [i32, i32]) + + with InsertionPoint(entry_block1): + value3 = Operation.create("custom.op3", results=[i32]).results[0] + # CHECK: Value(%[[VAL3:.*]] = "custom.op3"() : () -> i32) + print(value3) + value4 = Operation.create("custom.op4", results=[i32]).results[0] + # CHECK: Value(%[[VAL4:.*]] = "custom.op4"() : () -> i32) + print(value4) + + f = func.FuncOp("test", ([i32, i32], [])) + entry_block2 = Block.create_at_start(f.operation.regions[0], [i32, i32]) + with InsertionPoint(entry_block2): + value5 = Operation.create("custom.op5", results=[i32]).results[0] + # CHECK: Value(%[[VAL5:.*]] = "custom.op5"() : () -> i32) + print(value5) + value6 = Operation.create("custom.op6", results=[i32]).results[0] + # CHECK: Value(%[[VAL6:.*]] = "custom.op6"() : () -> i32) + print(value6) + + func.ReturnOp([]) + + func.ReturnOp([]) + + # CHECK: %[[VAL1]] + print(value.get_name_as_operand()) + # CHECK: %[[VAL2]] + print(value2.get_name_as_operand()) + # CHECK: %[[VAL3]] + print(value3.get_name_as_operand()) + # CHECK: %[[VAL4]] + print(value4.get_name_as_operand()) + + # CHECK: %0 + print(value3.get_name_as_operand(should_use_local_scope=True)) + # CHECK: %1 + print(value4.get_name_as_operand(should_use_local_scope=True)) + + # CHECK: %[[VAL5]] + print(value5.get_name_as_operand()) + # CHECK: %[[VAL6]] + print(value6.get_name_as_operand()) + + # CHECK: %[[ARG0:.*]] + print(entry_block1.arguments[0].get_name_as_operand()) + # CHECK: %[[ARG1:.*]] + print(entry_block1.arguments[1].get_name_as_operand()) + + # CHECK: %[[ARG2:.*]] + print(entry_block2.arguments[0].get_name_as_operand()) + # CHECK: %[[ARG3:.*]] + print(entry_block2.arguments[1].get_name_as_operand()) + + # CHECK: module { + # CHECK: %[[VAL1]] = "custom.op1"() : () -> i32 + # CHECK: %[[VAL2]] = "custom.op2"() : () -> i32 + # CHECK: func.func @test(%[[ARG0]]: i32, %[[ARG1]]: i32) { + # CHECK: %[[VAL3]] = "custom.op3"() : () -> i32 + # CHECK: %[[VAL4]] = "custom.op4"() : () -> i32 + # CHECK: func @test(%[[ARG2]]: i32, %[[ARG3]]: i32) { + # CHECK: %[[VAL5]] = "custom.op5"() : () -> i32 + # CHECK: %[[VAL6]] = "custom.op6"() : () -> i32 + # CHECK: return + # CHECK: } + # CHECK: return + # CHECK: } + # CHECK: } + print(module) + + value2.owner.detach_from_parent() + # CHECK: %0 + print(value2.get_name_as_operand())