[flang] GET_COMMAND_ARGUMENT(ERRMSG) runtime implementation

[rovka]

Summary

Implement the final part of GET_COMMAND_ARGUMENT, i.e. the handling of
ERRMSG. This uses some of the infrastructure in stat.h and gets rid of
the magic numbers that we were using for return codes.

[rovka]

Rebase.

[rovka]

Rebase again.

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

 #define FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT 256
 
 #define FORTRAN_RUNTIME_STAT_FAILED_IMAGE 101
 #define FORTRAN_RUNTIME_STAT_LOCKED 102
 #define FORTRAN_RUNTIME_STAT_LOCKED_OTHER_IMAGE 103
 #define FORTRAN_RUNTIME_STAT_STOPPED_IMAGE 104
 #define FORTRAN_RUNTIME_STAT_UNLOCKED 105
 #define FORTRAN_RUNTIME_STAT_UNLOCKED_FAILED_IMAGE 106
+
+#if 0
+Status codes for GET_COMMAND_ARGUMENT. The status for 'value too short' needs
+to be -1, the others must be positive.
+#endif
+#define FORTRAN_RUNTIME_STAT_INVALID_ARG_NUMBER 107
+#define FORTRAN_RUNTIME_STAT_MISSING_ARG 108
+#define FORTRAN_RUNTIME_STAT_VALUE_TOO_SHORT -1
 #endif

flang/runtime/command.cpp

 //===-- runtime/command.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/command.h"
 #include "environment.h"
+#include "stat.h"
 #include "flang/Runtime/descriptor.h"
 #include <limits>
 
 namespace Fortran::runtime {
 using CountType = CppTypeFor<TypeCategory::Integer, 4>;
 using LengthType = CppTypeFor<TypeCategory::Integer, 8>;
 
 CountType RTNAME(ArgumentCount)() {

 }
 
 CppTypeFor<TypeCategory::Integer, 4> RTNAME(ArgumentValue)(
     CountType n, const Descriptor *value, const Descriptor *errmsg) {
   if (n < 0 || n >= executionEnvironment.argc) {
     if (IsValidCharDescriptor(value)) {
       FillWithSpaces(value);
     }
-    return 1;
+    return ToErrmsg(errmsg, StatInvalidArgumentNumber);
   }
 
   if (IsValidCharDescriptor(value)) {
     LengthType argLen{ArgumentLength(n)};
     if (argLen <= 0) {
       FillWithSpaces(value);
-      return 2;
+      return ToErrmsg(errmsg, StatMissingArgument);
     }
     if (argLen >= static_cast<LengthType>(value->ElementBytes())) {
-      return -1;
+      return ToErrmsg(errmsg, StatValueTooShort);
     }
     std::strncpy(
         value->OffsetElement(), executionEnvironment.argv[n], argLen + 1);
   }
-  return 0;
+  return StatOk;
 }
 } // namespace Fortran::runtime

flang/runtime/stat.h

enum Stat {
   StatFailedImage = FORTRAN_RUNTIME_STAT_FAILED_IMAGE,
   StatLocked = FORTRAN_RUNTIME_STAT_LOCKED,
   StatLockedOtherImage = FORTRAN_RUNTIME_STAT_LOCKED_OTHER_IMAGE,
   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,
 };
 
 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

case StatLockedOtherImage:
     return "Other image locked";
   case StatStoppedImage:
     return "Image stopped";
   case StatUnlocked:
     return "Unlocked";
   case StatUnlockedFailedImage:
     return "Failed image unlocked";
 
+  case StatInvalidArgumentNumber:
+    return "Invalid argument number";
+  case StatMissingArgument:
+    return "Missing argument";
+  case StatValueTooShort:
+    return "Value too short";
+
   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/CommandTest.cpp

 //===-- flang/unittests/RuntimeGTest/CommandTest.cpp ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/command.h"
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "flang/Runtime/descriptor.h"
 #include "flang/Runtime/main.h"
 
 using namespace Fortran::runtime;
+using ::testing::StartsWith;
 
-template <std::size_t n = 128>
+template <std::size_t n = 64>
 static OwningPtr<Descriptor> CreateEmptyCharDescriptor() {
   OwningPtr<Descriptor> descriptor{Descriptor::Create(
       sizeof(char), n, nullptr, 0, nullptr, CFI_attribute_allocatable)};
   if (descriptor->Allocate() != 0) {
     return nullptr;
   }
   return descriptor;
 }
 
 class CommandFixture : public ::testing::Test {
 protected:
   CommandFixture(int argc, const char *argv[]) {
     RTNAME(ProgramStart)(argc, argv, {});
   }
 
   void CheckArgumentValue(int n, const char *argv) const {
     OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
     ASSERT_NE(value, nullptr);
 
     EXPECT_EQ(RTNAME(ArgumentValue)(n, value.get(), nullptr), 0);
     EXPECT_STREQ(value->OffsetElement(), argv);
   }
 
-  void CheckMissingArgumentValue(int n) const {
+  void CheckMissingArgumentValue(int n, const char *errStr = nullptr) const {
     OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
     ASSERT_NE(value, nullptr);
 
-    EXPECT_GT(RTNAME(ArgumentValue)(n, value.get(), nullptr), 0);
+    OwningPtr<Descriptor> err{errStr ? CreateEmptyCharDescriptor() : nullptr};
+
+    EXPECT_GT(RTNAME(ArgumentValue)(n, value.get(), err.get()), 0);
 
     std::string spaces(value->ElementBytes(), ' ');
     EXPECT_STREQ(value->OffsetElement(), spaces.c_str());
+
+    if (errStr) {
+      EXPECT_THAT(err->OffsetElement(), StartsWith(errStr));
+    }
   }
 };
 
 static const char *commandOnlyArgv[]{"aProgram"};
 class ZeroArguments : public CommandFixture {
 protected:
   ZeroArguments() : CommandFixture(1, commandOnlyArgv) {}
 };
TEST_F(SeveralArguments, ArgumentLength) {
   EXPECT_EQ(22, RTNAME(ArgumentLength)(3));
   EXPECT_EQ(1, RTNAME(ArgumentLength)(4));
   EXPECT_EQ(0, RTNAME(ArgumentLength)(5));
 }
 
 TEST_F(SeveralArguments, ArgumentValue) {
   CheckArgumentValue(0, severalArgsArgv[0]);
   CheckArgumentValue(1, severalArgsArgv[1]);
-  CheckMissingArgumentValue(2);
   CheckArgumentValue(3, severalArgsArgv[3]);
   CheckArgumentValue(4, severalArgsArgv[4]);
 }
 
 TEST_F(SeveralArguments, NoArgumentValue) {
   // Make sure we don't crash if the 'value' and 'error' parameters aren't
   // passed.
   EXPECT_EQ(RTNAME(ArgumentValue)(2, nullptr, nullptr), 0);
   EXPECT_GT(RTNAME(ArgumentValue)(-1, nullptr, nullptr), 0);
 }
 
-TEST_F(SeveralArguments, ArgumentValueErrors) {
-  CheckMissingArgumentValue(-1);
+TEST_F(SeveralArguments, MissingArguments) {
+  CheckMissingArgumentValue(-1, "Invalid argument number");
+  CheckMissingArgumentValue(2, "Missing argument");
+  CheckMissingArgumentValue(5, "Invalid argument number");
   CheckMissingArgumentValue(5);
+}
 
+TEST_F(SeveralArguments, ValueTooShort) {
   OwningPtr<Descriptor> tooShort{CreateEmptyCharDescriptor<16>()};
   ASSERT_NE(tooShort, nullptr);
   EXPECT_EQ(RTNAME(ArgumentValue)(1, tooShort.get(), nullptr), -1);
+
+  OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor()};
+  ASSERT_NE(errMsg, nullptr);
+  EXPECT_EQ(RTNAME(ArgumentValue)(1, tooShort.get(), errMsg.get()), -1);
+  EXPECT_THAT(errMsg->OffsetElement(), StartsWith("Value too short"));
+}
+
+TEST_F(SeveralArguments, ErrMsgTooShort) {
+  OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor<3>()};
+  EXPECT_GT(RTNAME(ArgumentValue)(-1, nullptr, errMsg.get()), 0);
+  EXPECT_STREQ(errMsg->OffsetElement(), "Inv");
 }