[NFC][flang] Distinguish MATMUL and MATMUL-TRANSPOSE printouts.

[vzakhari]

Summary

When MatmulTranpose reports incorrect shapes of the arguments
it cannot represent itself as MATMUL, because the reading
of the first argument's shape will be confusing.

[kiranchandramohan]

LG.

[vzakhari]

Thank you for the review, Kiran!

I guess the messages could be changed to report the corresponding MATMUL or TRANSPOSE errors depending on which part of the combined call the error is related to, but I will leave the decision to Tom. This is just a quick change to avoid confusing reports from the runtime.

[kiranchandramohan]

In D155911#4523089, @vzakhari wrote:

Thank you for the review, Kiran!

I guess the messages could be changed to report the corresponding MATMUL or TRANSPOSE errors depending on which part of the combined call the error is related to, but I will leave the decision to Tom. This is just a quick change to avoid confusing reports from the runtime.

Sure. Tom is not yet back at work. I was just temporarily standing in for Tom here. Once he is back, he can update the messages if required. CC: @tblah

[tblah]

Thanks for stepping in @kiranchandramohan. I think combined messages for matmul-transpose are fine because the messages apply equally to both operations. I don't think these need to be especially user friendly because these messages shouldn't ever happen.

If somebody really does want to reference them to a real intrinsic in source then I think the TRANSPOSE should be used because conceptually that is evaluated first.

flang/runtime/matmul-transpose.cpp

template <bool IS_ALLOCATING, TypeCategory RCAT, int RKIND, typename XT,
     typename YT>
 inline static void DoMatmulTranspose(
     std::conditional_t<IS_ALLOCATING, Descriptor, const Descriptor> &result,
     const Descriptor &x, const Descriptor &y, Terminator &terminator) {
   int xRank{x.rank()};
   int yRank{y.rank()};
   int resRank{xRank + yRank - 2};
   if (xRank * yRank != 2 * resRank) {
-    terminator.Crash("MATMUL: bad argument ranks (%d * %d)", xRank, yRank);
+    terminator.Crash(
+        "MATMUL-TRANSPOSE: bad argument ranks (%d * %d)", xRank, yRank);
   }
   SubscriptValue extent[2]{x.GetDimension(1).Extent(),
       resRank == 2 ? y.GetDimension(1).Extent() : 0};
   if constexpr (IS_ALLOCATING) {
     result.Establish(
         RCAT, RKIND, nullptr, resRank, extent, CFI_attribute_allocatable);
     for (int j{0}; j < resRank; ++j) {
       result.GetDimension(j).SetBounds(1, extent[j]);
     }
     if (int stat{result.Allocate()}) {
       terminator.Crash(
-          "MATMUL: could not allocate memory for result; STAT=%d", stat);
+          "MATMUL-TRANSPOSE: could not allocate memory for result; STAT=%d",
+          stat);
     }
   } else {
     RUNTIME_CHECK(terminator, resRank == result.rank());
     RUNTIME_CHECK(
         terminator, result.ElementBytes() == static_cast<std::size_t>(RKIND));
     RUNTIME_CHECK(terminator, result.GetDimension(0).Extent() == extent[0]);
     RUNTIME_CHECK(terminator,
         resRank == 1 || result.GetDimension(1).Extent() == extent[1]);
   }
   SubscriptValue n{x.GetDimension(0).Extent()};
   if (n != y.GetDimension(0).Extent()) {
-    terminator.Crash("MATMUL: unacceptable operand shapes (%jdx%jd, %jdx%jd)",
+    terminator.Crash(
+        "MATMUL-TRANSPOSE: unacceptable operand shapes (%jdx%jd, %jdx%jd)",
         static_cast<std::intmax_t>(x.GetDimension(0).Extent()),
         static_cast<std::intmax_t>(x.GetDimension(1).Extent()),
         static_cast<std::intmax_t>(y.GetDimension(0).Extent()),
         static_cast<std::intmax_t>(y.GetDimension(1).Extent()));
   }
   using WriteResult =
       CppTypeFor<RCAT == TypeCategory::Logical ? TypeCategory::Integer : RCAT,
           RKIND>;
if (x.IsContiguous() && y.IsContiguous() &&
       if (xRank == 2) { // M*V -> V
         MatrixTransposedTimesVector<RCAT, RKIND, XT, YT>(
             result.template OffsetElement<WriteResult>(), rows, n,
             x.OffsetElement<XT>(), y.OffsetElement<YT>());
         return;
       }
       // else V*M -> V (not allowed because TRANSPOSE() is only defined for rank
       // 1 matrices
-      terminator.Crash("MATMUL: unacceptable operand shapes (%jdx%jd, %jdx%jd)",
+      terminator.Crash(
+          "MATMUL-TRANSPOSE: unacceptable operand shapes (%jdx%jd, %jdx%jd)",
           static_cast<std::intmax_t>(x.GetDimension(0).Extent()),
           static_cast<std::intmax_t>(n),
           static_cast<std::intmax_t>(y.GetDimension(0).Extent()),
           static_cast<std::intmax_t>(y.GetDimension(1).Extent()));
       return;
     }
   }
   // General algorithms for LOGICAL and noncontiguity
for (SubscriptValue i{0}; i < rows; ++i) {
           res_i += x_ki * y_k;
         }
       }
       SubscriptValue resAt[1]{i + resLB[0]};
       *result.template Element<WriteResult>(resAt) = res_i;
     }
   } else { // V*M -> V
     // TRANSPOSE(V) not allowed by fortran standard
-    terminator.Crash("MATMUL: unacceptable operand shapes (%jdx%jd, %jdx%jd)",
+    terminator.Crash(
+        "MATMUL-TRANSPOSE: unacceptable operand shapes (%jdx%jd, %jdx%jd)",
         static_cast<std::intmax_t>(x.GetDimension(0).Extent()),
         static_cast<std::intmax_t>(n),
         static_cast<std::intmax_t>(y.GetDimension(0).Extent()),
         static_cast<std::intmax_t>(y.GetDimension(1).Extent()));
   }
 }
 
 // Maps the dynamic type information from the arguments' descriptors
template <TypeCategory YCAT, int YKIND> struct MM2 {
           if constexpr (Fortran::common::IsNumericTypeCategory(
                             resultType->first) ||
               resultType->first == TypeCategory::Logical) {
             return DoMatmulTranspose<IS_ALLOCATING, resultType->first,
                 resultType->second, CppTypeFor<XCAT, XKIND>,
                 CppTypeFor<YCAT, YKIND>>(result, x, y, terminator);
           }
         }
-        terminator.Crash("MATMUL: bad operand types (%d(%d), %d(%d))",
+        terminator.Crash("MATMUL-TRANSPOSE: bad operand types (%d(%d), %d(%d))",
             static_cast<int>(XCAT), XKIND, static_cast<int>(YCAT), YKIND);
       }
     };
     void operator()(ResultDescriptor &result, const Descriptor &x,
         const Descriptor &y, Terminator &terminator, TypeCategory yCat,
         int yKind) const {
       ApplyType<MM2, void>(yCat, yKind, terminator, result, x, y, terminator);
     }