[flang] Improve error message for move_alloc

[DavidTruby]

Summary

This patch improves the error message when MOVE_ALLOC is passed the same
allocated allocatable as both the to and from arguments.

flang/include/flang/Runtime/magic-numbers.h

 #define FORTRAN_RUNTIME_STAT_MISSING_ARG 108
 #define FORTRAN_RUNTIME_STAT_VALUE_TOO_SHORT -1
 
 #if 0
 Status codes for GET_ENVIRONMENT_VARIABLE. Values mandated by the standard.
 #endif
 #define FORTRAN_RUNTIME_STAT_MISSING_ENV_VAR 1
 #define FORTRAN_RUNTIME_STAT_ENV_VARS_UNSUPPORTED 2
+
+#if 0
+Processor-defined status code for MOVE_ALLOC where arguments are the
+same allocatable.
+#endif
+#define FORTRAN_RUNTIME_STAT_MOVE_ALLOC_SAME_ALLOCATABLE 109
+
 #endif

flang/runtime/allocatable.cpp

std::int32_t RTNAME(MoveAlloc)(Descriptor &to, Descriptor &from, bool hasStat,
   Terminator terminator{sourceFile, sourceLine};
   // Should be handled by semantic analysis
   RUNTIME_CHECK(terminator, to.type() == from.type());
   RUNTIME_CHECK(terminator, to.IsAllocatable() && from.IsAllocatable());
 
   // If to and from are the same allocatable they must not be allocated
   // and nothing should be done.
   if (from.raw().base_addr == to.raw().base_addr && from.IsAllocated()) {
-    return ReturnError(terminator, StatInvalidDescriptor, errMsg, hasStat);
+    return ReturnError(
+        terminator, StatMoveAllocSameAllocatable, errMsg, hasStat);
   }
 
   if (to.IsAllocated()) {
     int stat{to.Destroy(/*finalize=*/true)};
     if (stat != StatOk) {
       return ReturnError(terminator, stat, errMsg, hasStat);
     }
   }

flang/runtime/stat.h

enum Stat {
   StatStoppedImage = FORTRAN_RUNTIME_STAT_STOPPED_IMAGE,
   StatUnlocked = FORTRAN_RUNTIME_STAT_UNLOCKED,
   StatUnlockedFailedImage = FORTRAN_RUNTIME_STAT_UNLOCKED_FAILED_IMAGE,
 
   // Additional "processor-defined" STAT= values
   StatInvalidArgumentNumber = FORTRAN_RUNTIME_STAT_INVALID_ARG_NUMBER,
   StatMissingArgument = FORTRAN_RUNTIME_STAT_MISSING_ARG,
   StatValueTooShort = FORTRAN_RUNTIME_STAT_VALUE_TOO_SHORT,
+  StatMoveAllocSameAllocatable =
+      FORTRAN_RUNTIME_STAT_MOVE_ALLOC_SAME_ALLOCATABLE,
 };
 
 const char *StatErrorString(int);
 int ToErrmsg(const Descriptor *errmsg, int stat); // returns stat
 int ReturnError(Terminator &, int stat, const Descriptor *errmsg = nullptr,
     bool hasStat = false);
 } // namespace Fortran::runtime
 #endif // FORTRAN_RUNTIME_STAT_H

flang/runtime/stat.cpp

const char *StatErrorString(int stat) {
   case StatMissingArgument:
     return "Missing argument";
   case StatValueTooShort:
     return "Value too short";
 
   case StatMissingEnvVariable:
     return "Missing environment variable";
 
+  case StatMoveAllocSameAllocatable:
+    return "MOVE_ALLOC passed the same address as to and from";
+
   default:
     return nullptr;
   }
 }
 
 int ToErrmsg(const Descriptor *errmsg, int stat) {
   if (stat != StatOk && errmsg && errmsg->raw().base_addr &&
       errmsg->type() == TypeCode(TypeCategory::Character, 1) &&

flang/unittests/Runtime/Allocatable.cpp

TEST(AllocatableTest, MoveAlloc) {
 
   // move_alloc with the same deallocated array
   stat = RTNAME(MoveAlloc)(*b, *b, true, errMsg.get(), __FILE__, __LINE__);
   EXPECT_FALSE(b->IsAllocated());
   EXPECT_EQ(stat, 0);
 
   // move_alloc with the same allocated array should fail
   stat = RTNAME(MoveAlloc)(*a, *a, true, errMsg.get(), __FILE__, __LINE__);
-  EXPECT_EQ(stat, 18);
+  EXPECT_EQ(stat, 109);
   std::string_view errStr{errMsg->OffsetElement(), errMsg->ElementBytes()};
   auto trim_pos = errStr.find_last_not_of(' ');
   if (trim_pos != errStr.npos)
     errStr.remove_suffix(errStr.size() - trim_pos - 1);
-  EXPECT_EQ(errStr, "Invalid descriptor");
+  EXPECT_EQ(errStr, "MOVE_ALLOC passed the same address as to and from");
 }