Feature/vpto cpp bridge generalization

include/PTO/IR/CMakeLists.txt

@@ -31,6 +31,12 @@ mlir_tablegen(PTOAttrs.cpp.inc -gen-attrdef-defs -attrdefs-dialect=pto)
 mlir_tablegen(PTOEnums.h.inc -gen-enum-decls)
 mlir_tablegen(PTOEnums.cpp.inc -gen-enum-defs)
 
+# 生成 Attribute Interfaces 定义
+set(LLVM_TARGET_DEFINITIONS PTOAttrInterfaces.td)
+mlir_tablegen(PTOAttrInterfaces.h.inc -gen-attr-interface-decls)
+mlir_tablegen(PTOAttrInterfaces.cpp.inc -gen-attr-interface-defs)
+set(LLVM_TARGET_DEFINITIONS PTOOps.td)
+
 # ============================================================
 # 2. 处理 Interfaces (防止下个报错)
 # ============================================================

include/PTO/IR/PTO.h

@@ -57,6 +57,8 @@
 // PTO Attributes
 //===----------------------------------------------------------------------===//
 
+#include "PTO/IR/PTOAttrInterfaces.h.inc"
+
 #define GET_ATTRDEF_CLASSES
 #include "PTO/IR/PTOAttrs.h.inc"
 

include/PTO/IR/PTOAttrInterfaces.td

@@ -0,0 +1,51 @@
+// Copyright (c) 2026 Huawei Technologies Co., Ltd.
+// This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+// CANN Open Software License Agreement Version 2.0 (the "License").
+// Please refer to the License for details. You may not use this file except in compliance with the License.
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+// See LICENSE in the root of the software repository for the full text of the License.
+
+//===- PTOAttrInterfaces.td - PTO attribute interfaces ------*- tablegen -*-===//
+//===----------------------------------------------------------------------===//
+//
+// This is the definition file for PTO dialect attribute interfaces.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_PTO_IR_PTOATTRINTERFACES
+#define MLIR_DIALECT_PTO_IR_PTOATTRINTERFACES
+
+include "mlir/IR/AttrTypeBase.td"
+include "mlir/IR/OpBase.td"
+
+//===----------------------------------------------------------------------===//
+// Enum token reflection
+//===----------------------------------------------------------------------===//
+
+// Implemented by PTO enum attributes that can feed a VPTO bridge template
+// token. This MLIR build has no generic C++ runtime base for TableGen enum
+// attributes, so the declarative bridge lowering reflects the enum case
+// through this interface instead of knowing each attribute class: it
+// assembles `EnumType::Case` spellings from the whitelist `enum_type`
+// prefix and the enumerator symbol exposed here.
+def PTO_EnumTokenAttr : AttrInterface<"EnumTokenAttr"> {
+  let cppNamespace = "::mlir::pto";
+  let description = [{
+    An attribute whose value is one case of a PTO enum and can be rendered
+    as a C++ template token by the declarative VPTO bridge lowering.
+  }];
+  let methods = [
+    InterfaceMethod<
+      /*desc=*/[{
+        Returns the C++ enumerator symbol of the attribute's enum case
+        (e.g. "Partial" for `pto::AccPhase::Partial`).
+      }],
+      /*retTy=*/"llvm::StringRef",
+      /*methodName=*/"getEnumCaseSymbol",
+      /*args=*/(ins)
+    >,
+  ];
+}
+
+#endif // MLIR_DIALECT_PTO_IR_PTOATTRINTERFACES

include/PTO/IR/PTOAttrs.td

@@ -17,6 +17,7 @@
 #define MLIR_DIALECT_PTO_IR_PTOATTRS
 
 include "PTO/IR/PTODialect.td"
+include "PTO/IR/PTOAttrInterfaces.td"
 
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
 include "mlir/IR/AttrTypeBase.td"
@@ -867,7 +868,8 @@ def PTO_AccPhaseEnum : PTO_I32Enum<
     I32EnumAttrCase<"Final", 3, "final">
   ]>;
 
-def PTO_AccPhaseAttr : EnumAttr<PTO_Dialect, PTO_AccPhaseEnum, "acc_phase"> {
+def PTO_AccPhaseAttr : EnumAttr<PTO_Dialect, PTO_AccPhaseEnum, "acc_phase",
+    [DeclareAttrInterfaceMethods<PTO_EnumTokenAttr>]> {
   let summary = "TMATMUL / TMATMUL_ACC accumulation phase attribute";
 }
 

include/PTO/IR/PTOOps.td

@@ -2677,6 +2677,51 @@ def TFreeOp : PTO_TOp<"tfree", [
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// C++ Interface Bridge Ops
+//===----------------------------------------------------------------------===//
+//
+// These internal ops form the generic VPTO C++ interface bridge. A
+// family-specific pass
+// (e.g. the TPipe family pass) rewrites its internal ops into bridge ops
+// carrying only the wrapper callee name and ABI values. The generic bridge
+// lowering pass then mechanically converts them into calls to wrapper
+// functions whose implementations come from externally compiled device
+// bitcode linked into the VPTO device module.
+
+def BridgeCallOp : PTO_Op<"bridge_call", [
+    DeclareOpInterfaceMethods<MemoryEffectsOpInterface>
+]> {
+  let summary = "Generic call into an externally linked C++ wrapper entry";
+
+  let arguments = (ins
+      StrAttr:$callee,
+      OptionalAttr<StrAttr>:$storage_size_callee,
+      Variadic<AnyType>:$args
+  );
+
+  let results = (outs Variadic<AnyType>:$results);
+
+  let assemblyFormat = [{
+    $callee
+    (`{` `storage_size_callee` `=` $storage_size_callee^ `}`)?
+    (`(` $args^ `:` type($args) `)`)?
+    attr-dict
+    (`->` type($results)^)?
+  }];
+}
+
+def BridgeIntToPtrOp : PTO_Op<"bridge_inttoptr"> {
+  let summary = "Generic bridge address materialization (i64 to PTO pointer)";
+
+  let arguments = (ins SignlessIntegerLike:$addr);
+  let results = (outs AnyType:$result);
+
+  let assemblyFormat = [{
+    $addr attr-dict `:` type($addr) `->` type($result)
+  }];
+}
+
 //===----------------------------------------------------------------------===//
 // Synchronization Ops
 //===----------------------------------------------------------------------===//

include/PTO/Transforms/PTOCppTokens.h

@@ -0,0 +1,82 @@
+// Copyright (c) 2026 Huawei Technologies Co., Ltd.
+// This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+// CANN Open Software License Agreement Version 2.0 (the "License").
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.huawei.com/
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+// See LICENSE in the root of the software repository for the full text of the License.
+
+//===- PTOCppTokens.h - shared PTO-ISA C++ token mappings -------*- C++ -*-===//
+//===----------------------------------------------------------------------===//
+//
+// Single source of truth for the pure mappings from IR facts (element
+// types, enums, integer attribute values) to PTO-ISA C++ spellings. Both
+// the EmitC backend and the VPTO C++ interface bridge render the same
+// pto-isa template tokens; they share these mapping functions and keep
+// their own assembly logic (which template arguments to emit, how the
+// tokens are consumed).
+//
+// Every builder takes a `qualifier` prefix that is prepended to the
+// pto-isa constant/type spelling: the bridge passes "pto::" (the wrapper
+// is a standalone translation unit and always spells fully qualified
+// names), the EmitC backend passes an empty string (its output relies on
+// the surrounding namespace context).
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_PTO_TRANSFORMS_PTOCPPTOKENS_H
+#define MLIR_DIALECT_PTO_TRANSFORMS_PTOCPPTOKENS_H
+
+#include "PTO/IR/PTO.h"
+#include "mlir/IR/Types.h"
+#include "mlir/Support/LLVM.h"
+#include "mlir/Support/LogicalResult.h"
+#include "llvm/ADT/StringRef.h"
+#include <string>
+
+namespace mlir {
+namespace pto {
+
+/// Builds the C++ element type token (e.g. "float", "half", "int8_t") for
+/// an MLIR element type. Falls back to "float" for unrecognized types.
+std::string getPTOCppElementTypeToken(Type elementType);
+
+/// Builds the `TileSplitAxis::TILE_*` token for a split value (0..4).
+/// Fails for values outside that range.
+FailureOr<std::string> getPTOCppTileSplitToken(int64_t split,
+                                               llvm::StringRef qualifier);
+
+/// Builds the `Direction::DIR_*` token for a local pipe dir_mask (1=C2V,
+/// 2=V2C, 3=BOTH). The L2G2L "_GM" variants are an EmitC-side extension
+/// and are not part of this core mapping. Fails for other masks.
+FailureOr<std::string> getPTOCppDirectionToken(int8_t dirMask,
+                                               llvm::StringRef qualifier);
+
+/// Builds the `TileType::*` token for a local tile address space. Fails
+/// for address spaces with no TileType mapping (e.g. global memory);
+/// callers apply their own fallback policy for those.
+FailureOr<std::string> getPTOCppTileTypeToken(AddressSpace addressSpace,
+                                              llvm::StringRef qualifier);
+
+/// Builds the `BLayout::*` token. Fails for values outside the closed set.
+FailureOr<std::string> getPTOCppBLayoutToken(BLayout bLayout,
+                                             llvm::StringRef qualifier);
+
+/// Builds the `SLayout::*` token. Fails for values outside the closed set.
+FailureOr<std::string> getPTOCppSLayoutToken(SLayout sLayout,
+                                             llvm::StringRef qualifier);
+
+/// Renders the `TPipe<flagBase, Direction, slotSize, slotNum, localSlotNum,
+/// nosplit>` spelling; `dirTok` is an already rendered direction token.
+std::string renderTPipeSpelling(int32_t flagBase, llvm::StringRef dirTok,
+                                int32_t slotSize, int32_t slotNum,
+                                int32_t localSlotNum, bool nosplit,
+                                llvm::StringRef qualifier);
+
+} // namespace pto
+} // namespace mlir
+
+#endif // MLIR_DIALECT_PTO_TRANSFORMS_PTOCPPTOKENS_H

include/PTO/Transforms/Passes.h

@@ -45,6 +45,10 @@ std::unique_ptr<Pass> createPTOValidatePhysicalSectionBoundariesPass();
 std::unique_ptr<Pass> createPTOMaterializeTileOpSectionsPass();
 std::unique_ptr<Pass> createVPTOSplitCVModulePass();
 std::unique_ptr<Pass> createVPTONormalizeContainerPass();
+std::unique_ptr<Pass> createPTOLowerPipeFamilyOpsPass();
+std::unique_ptr<Pass> createPTOLowerDeclarativeBridgeOpsPass();
+std::unique_ptr<Pass> createVPTOBridgeLoweringPass();
+std::unique_ptr<Pass> createVPTOBridgeWrapperGenPass();
 std::unique_ptr<Pass> createPTOVerifyTFreePass();
 
 // Creates a pass for ...

include/PTO/Transforms/Passes.td

@@ -426,6 +426,109 @@ def PTOMaterializeTileOpSections
   ];
 }
 
+def PTOLowerPipeFamilyOps : Pass<"pto-lower-pipe-family-ops", "mlir::func::FuncOp"> {
+  let summary = "Lower internal TPipe ops into generic VPTO bridge ops";
+  let description = [{
+    TPipe family pass of the VPTO C++ interface bridge. It rewrites the
+    internal pipe ops (pto.initialize_l2l_pipe / pto.tpush / pto.tpop /
+    pto.tfree) and the tile handles they consume (pto.alloc_tile /
+    pto.declare_tile / pto.tile_buf_addr) into generic pto.bridge_call /
+    pto.bridge_inttoptr ops that carry only wrapper callee names and ABI
+    values. All pipe family semantics (config validation, storage handle
+    flow, and the runtime rebinding of a declared tile to the FIFO slot
+    returned by TPOP) are resolved here so that the generic bridge lowering
+    stays family-agnostic.
+  }];
+  let constructor = "mlir::pto::createPTOLowerPipeFamilyOpsPass()";
+  let options = [
+    Option<"whitelistPath", "whitelist-path", "std::string",
+           /*default=*/"\"\"",
+           "Path to the VPTO bridge whitelist YAML; falls back to the "
+           "PTOAS_VPTO_BRIDGE_WHITELIST environment variable, "
+           "then to the built-in default whitelist">
+  ];
+  let dependentDialects = [
+    "mlir::pto::PTODialect",
+    "mlir::arith::ArithDialect"
+  ];
+}
+
+def PTOLowerDeclarativeBridgeOps : Pass<"pto-lower-declarative-bridge-ops", "mlir::func::FuncOp"> {
+  let summary = "Lower whitelist-routed ops through the declarative VPTO "
+                "bridge channel";
+  let description = [{
+    Declarative lowering channel of the VPTO C++ interface bridge, and the
+    default channel of every whitelist entry. It rewrites each entry into a
+    void pto.bridge_call using only the whitelist description: each abi row
+    binds a wrapper argument to an IR operand position whose planned
+    alloc_tile address becomes the i64 call argument, and the wrapper
+    specialization is collected from the operand tile types (keyed by the
+    abi role) plus optional enum attributes. Ops needing family semantics
+    (storage lifecycle, address rebinding) opt out with `lowering: custom`
+    and stay on their family pass. Routing is whitelist driven: unrouted
+    ops keep flowing through their regular non-bridge lowering path.
+  }];
+  let constructor = "mlir::pto::createPTOLowerDeclarativeBridgeOpsPass()";
+  let options = [
+    Option<"whitelistPath", "whitelist-path", "std::string",
+           /*default=*/"\"\"",
+           "Path to the VPTO bridge whitelist YAML; falls back to the "
+           "PTOAS_VPTO_BRIDGE_WHITELIST environment variable, "
+           "then to the built-in default whitelist">
+  ];
+  let dependentDialects = [
+    "mlir::pto::PTODialect"
+  ];
+}
+
+def VPTOBridgeLowering : Pass<"vpto-bridge-lowering", "ModuleOp"> {
+  let summary = "Lower generic bridge ops into C++ wrapper calls";
+  let description = [{
+    Generic bridge lowering pass of the VPTO C++ interface bridge. It knows
+    nothing about individual PTO-ISA interface families: it validates each
+    pto.bridge_call against the bridge whitelist and mechanically lowers it
+    into a call to the wrapper entry, materializing the wrapper declaration
+    at module level. Entries carrying storage_size_callee additionally
+    synthesize the stateful-object pattern (size query + stack storage).
+    pto.bridge_inttoptr is lowered to llvm.inttoptr.
+  }];
+  let constructor = "mlir::pto::createVPTOBridgeLoweringPass()";
+  let options = [
+    Option<"whitelistPath", "whitelist-path", "std::string",
+           /*default=*/"\"\"",
+           "Path to the VPTO bridge whitelist YAML; falls back to the "
+           "PTOAS_VPTO_BRIDGE_WHITELIST environment variable, "
+           "then to the built-in default whitelist">
+  ];
+  let dependentDialects = [
+    "mlir::pto::PTODialect",
+    "mlir::func::FuncDialect",
+    "mlir::LLVM::LLVMDialect"
+  ];
+}
+
+def VPTOBridgeWrapperGen : Pass<"pto-emit-vpto-bridge-wrapper", "ModuleOp"> {
+  let summary = "Render the VPTO bridge wrapper source from the collected spec";
+  let description = [{
+    Wrapper generation pass of the VPTO C++ interface bridge. It reads the
+    pipe bridge specialization collected by the family passes in the
+    `pto.vpto.bridge.spec` module attribute (TPipe/Tile/split C++ template
+    tokens plus the whitelist wrapper entry names), renders the complete
+    bridge wrapper C++ source, and stores it in the
+    `pto.vpto.bridge.wrapper_source` module attribute for object emission to
+    compile and link. The spec attribute is removed once rendered. Modules
+    without a bridge spec are left untouched.
+  }];
+  let constructor = "mlir::pto::createVPTOBridgeWrapperGenPass()";
+  let options = [
+    Option<"whitelistPath", "whitelist-path", "std::string",
+           /*default=*/"\"\"",
+           "Path to the VPTO bridge whitelist YAML; falls back to the "
+           "PTOAS_VPTO_BRIDGE_WHITELIST environment variable, "
+           "then to the built-in default whitelist">
+  ];
+}
+
 def VPTOSplitCVModule : Pass<"vpto-split-cv-module", "ModuleOp"> {
   let summary = "Split a VPTO module with cube/vector sections into kernel modules";
   let description = [{

include/PTO/Transforms/TileOpExpansionUtils.h

@@ -22,7 +22,8 @@ inline bool isTileLibExpandableOp(Operation *op) {
   }
   return !isa<TReshapeOp, TSyncOp, TAllocToAivOp, TAllocToAicOp,
               TPushToAivOp, TPushToAicOp, TPopFromAicOp, TPopFromAivOp,
-              TFreeFromAicOp, TFreeFromAivOp>(op);
+              TFreeFromAicOp, TFreeFromAivOp, TAllocOp, TPushOp, TPopOp,
+              TFreeOp>(op);
 }
 
 } // namespace mlir::pto