fix(t2l): handle detached normalized mask bases

Stop relying on the parent operation of a block argument while dialect conversion may detach its owner block. Carry the exact i1-to-i8 normalization classification from base resolution and initialize BlockData directly from the verified memref<?xi8> remap, while preserving the existing parser for ordinary adaptor bases.

Author: elstainniles

third_party/ascend/lib/TritonToLinalg/BlockPtrAnalysis.cpp

@@ -1660,19 +1660,27 @@ memref::ReinterpretCastOp createRedundantOp(triton::MakeTensorPtrOp op,
   return castOp;
 }
 
-static FailureOr<Value>
+// Carries the converted runtime descriptor and records whether the resolver
+// has already proven the complete ptr<i1>-to-ptr<i8> normalization contract.
+// That exact fallback can initialize BlockData without consulting conversion
+// state attached to the original bitcast result.
+struct ResolvedMakeTensorPtrBase {
+  Value value;
+  bool normalizedI1ToI8 = false;
+};
+
+static FailureOr<ResolvedMakeTensorPtrBase>
 resolveMakeTensorPtrBase(triton::MakeTensorPtrOp op, Value adaptorBase,
                          ConversionPatternRewriter &rewriter) {
   if (adaptorBase && isa<BaseMemRefType>(adaptorBase.getType()))
-    return adaptorBase;
+    return ResolvedMakeTensorPtrBase{adaptorBase};
 
   auto bitcast = op.getBase().getDefiningOp<triton::BitcastOp>();
   if (!bitcast)
     return failure();
 
   auto sourceArgument = dyn_cast<BlockArgument>(bitcast.getSrc());
-  if (!sourceArgument ||
-      !isa<triton::FuncOp>(sourceArgument.getOwner()->getParentOp()))
+  if (!sourceArgument)
     return failure();
 
   auto sourcePointer =
@@ -1693,28 +1701,38 @@ resolveMakeTensorPtrBase(triton::MakeTensorPtrOp op, Value adaptorBase,
   if (!sourceMemRef || sourceMemRef != expectedType)
     return failure();
 
-  return convertedSource;
+  return ResolvedMakeTensorPtrBase{convertedSource,
+                                   /*normalizedI1ToI8=*/true};
 }
 
 LogicalResult BlockDataParser::rewriteMakeTensorPtrOp(
     triton::MakeTensorPtrOp op, Value convertedBase,
     ConversionPatternRewriter &rewriter,
     llvm::SmallDenseMap<Value, BlockData> &known) {
-  FailureOr<Value> resolvedBase =
+  FailureOr<ResolvedMakeTensorPtrBase> resolvedBase =
       resolveMakeTensorPtrBase(op, convertedBase, rewriter);
   if (failed(resolvedBase)) {
     op.emitOpError("expected the converted base to be a memref descriptor");
     return failure();
   }
-  convertedBase = *resolvedBase;
+  convertedBase = resolvedBase->value;
   Location loc = op.getLoc();
   BlockData data;
 
-  // Parse the original producer only for semantic information such as a
-  // bitcast element type. The runtime source always comes from the resolved
-  // converted base so SCF-selected memref descriptors are not bypassed.
-  if (failed(BlockDataParser::parse(op.getBase(), data, loc, rewriter, known)))
-    return failure();
+  if (resolvedBase->normalizedI1ToI8) {
+    // The resolver has already established the complete normalized mask-base
+    // contract. Avoid querying the bitcast result mapping while dialect
+    // conversion may still be rewriting its owner block.
+    data.setSource(convertedBase);
+    data.setResElemTy(rewriter.getIntegerType(8));
+  } else {
+    // Parse the original producer only for semantic information such as a
+    // bitcast element type. The runtime source always comes from the resolved
+    // converted base so SCF-selected memref descriptors are not bypassed.
+    if (failed(
+            BlockDataParser::parse(op.getBase(), data, loc, rewriter, known)))
+      return failure();
+  }
   if (!data.hasSource()) {
     op.emitOpError("failed to resolve the converted scalar base");
     return failure();