[flang] Change "bad kind" messages in the runtime to "not yet implemented"

[PeteSteinfeld]

Summary

Similar to change D125046.

If a programmer is able to compile and link a program that contains types that
are not yet supported by the runtime, it must be because they're not yet
implemented.

This change will make it easier to find unimplemented code in tests.

[jeanPerier]

LGTM

flang/runtime/character.cpp

case 8:
     LenTrim<CppTypeFor<TypeCategory::Integer, 8>, CHAR>(
         result, string, terminator);
     break;
   case 16:
     LenTrim<CppTypeFor<TypeCategory::Integer, 16>, CHAR>(
         result, string, terminator);
     break;
   default:
-    terminator.Crash("LEN_TRIM: bad KIND=%d", kind);
+    terminator.Crash("not yet implemented: LEN_TRIM: KIND=%d", kind);
   }
 }
 
 // INDEX implementation
 template <typename CHAR>
 inline std::size_t Index(const CHAR *x, std::size_t xLen, const CHAR *want,
     std::size_t wantLen, bool back) {
   if (xLen < wantLen) {
case 8:
     GeneralCharFunc<CppTypeFor<TypeCategory::Integer, 8>, CHAR, FUNC>(
         result, string, arg, back, terminator);
     break;
   case 16:
     GeneralCharFunc<CppTypeFor<TypeCategory::Integer, 16>, CHAR, FUNC>(
         result, string, arg, back, terminator);
     break;
   default:
-    terminator.Crash("INDEX/SCAN/VERIFY: bad KIND=%d", kind);
+    terminator.Crash("not yet implemented: INDEX/SCAN/VERIFY: KIND=%d", kind);
   }
 }
 
 template <typename TO, typename FROM>
 static void CopyAndPad(
     TO *to, const FROM *from, std::size_t toChars, std::size_t fromChars) {
   if constexpr (sizeof(TO) != sizeof(FROM)) {
     std::size_t copyChars{std::min(toChars, fromChars)};

flang/runtime/random.cpp

case 10:
     Generate<CppTypeFor<TypeCategory::Real, 10>, 64>(harvest);
     break;
 #elif LONG_DOUBLE == 128
   case 16:
     Generate<CppTypeFor<TypeCategory::Real, 16>, 113>(harvest);
     break;
 #endif
   default:
-    terminator.Crash("RANDOM_NUMBER(): bad REAL kind %d", kind);
+    terminator.Crash(
+        "not yet implemented: RANDOM_NUMBER(): REAL kind %d", kind);
   }
 }
 
 void RTNAME(RandomSeedSize)(
     const Descriptor &size, const char *source, int line) {
   Terminator terminator{source, line};
   auto typeCode{size.type().GetCategoryAndKind()};
   RUNTIME_CHECK(terminator,
       size.rank() == 0 && typeCode && typeCode->first == TypeCategory::Integer);
   int kind{typeCode->second};
   switch (kind) {
   case 4:
     *size.OffsetElement<CppTypeFor<TypeCategory::Integer, 4>>() = 1;
     break;
   case 8:
     *size.OffsetElement<CppTypeFor<TypeCategory::Integer, 8>>() = 1;
     break;
   default:
-    terminator.Crash("RANDOM_SEED(SIZE=): bad kind %d\n", kind);
+    terminator.Crash(
+        "not yet implemented: RANDOM_SEED(SIZE=): kind %d\n", kind);
   }
 }
 
 void RTNAME(RandomSeedPut)(
     const Descriptor &put, const char *source, int line) {
   Terminator terminator{source, line};
   auto typeCode{put.type().GetCategoryAndKind()};
   RUNTIME_CHECK(terminator,
       put.rank() == 1 && typeCode && typeCode->first == TypeCategory::Integer &&
           put.GetDimension(0).Extent() >= 1);
   int kind{typeCode->second};
   GeneratedWord seed;
   switch (kind) {
   case 4:
     seed = *put.OffsetElement<CppTypeFor<TypeCategory::Integer, 4>>();
     break;
   case 8:
     seed = *put.OffsetElement<CppTypeFor<TypeCategory::Integer, 8>>();
     break;
   default:
-    terminator.Crash("RANDOM_SEED(PUT=): bad kind %d\n", kind);
+    terminator.Crash("not yet implemented: RANDOM_SEED(PUT=): kind %d\n", kind);
   }
   {
     CriticalSection critical{lock};
     generator.seed(seed);
   }
 }
 
 void RTNAME(RandomSeedDefaultPut)() {
void RTNAME(RandomSeedGet)(
   switch (kind) {
   case 4:
     *got.OffsetElement<CppTypeFor<TypeCategory::Integer, 4>>() = seed;
     break;
   case 8:
     *got.OffsetElement<CppTypeFor<TypeCategory::Integer, 8>>() = seed;
     break;
   default:
-    terminator.Crash("RANDOM_SEED(GET=): bad kind %d\n", kind);
+    terminator.Crash("not yet implemented: RANDOM_SEED(GET=): kind %d\n", kind);
   }
 }
 } // extern "C"
 } // namespace Fortran::runtime

flang/runtime/tools.cpp

for (int j{0}; j < rank; ++j) {
             funcName, j + 1, toName, toExtent, xName, xExtent);
       }
     }
   }
 }
 
 void CheckIntegerKind(Terminator &terminator, int kind, const char *intrinsic) {
   if (kind < 1 || kind > 16 || (kind & (kind - 1)) != 0) {
-    terminator.Crash("%s: bad KIND=%d argument", intrinsic, kind);
+    terminator.Crash(
+        "not yet implemented: %s: KIND=%d argument", intrinsic, kind);
   }
 }
 } // namespace Fortran::runtime

flang/runtime/transformational.cpp

case 2:
       std::fill_n(result.OffsetElement<char16_t>(), bytes / 2,
           static_cast<char16_t>(' '));
       break;
     case 4:
       std::fill_n(result.OffsetElement<char32_t>(), bytes / 4,
           static_cast<char32_t>(' '));
       break;
     default:
-      terminator.Crash("EOSHIFT: bad CHARACTER kind %d", kind);
+      terminator.Crash("not yet implemented: EOSHIFT: CHARACTER kind %d", kind);
     }
   } else {
     std::memset(result.raw().base_addr, 0, bytes);
   }
 }
 
 static inline std::size_t AllocateResult(Descriptor &result,
     const Descriptor &source, int rank, const SubscriptValue extent[],