[flang] Support GNU extensions IARGC and GETARG in runtime

[peixin]

Summary

The GNU extension intrinsic IARGC is equivalent to
COMMAND_ARGUMENT_COUNT, and the GETARG is similar to
GET_COMMAND_ARGUMENT, but with less arguments. Reuse the runtime of
COMMAND_ARGUMENT_COUNT and GET_COMMAND_ARGUMENT for IARGC and GETARG.

[kiranchandramohan]

I think we need any entry for these two non-standard intrinsics in flang/docs/Extensions.md.

flang/lib/Evaluate/intrinsics.cpp

479 ↗

(On Diff #458978)

This should be after the second iand?

[clementval]

In D133558#3779517, @kiranchandramohan wrote:

I think we need any entry for these two non-standard intrinsics in flang/docs/Extensions.md.

What is the current stand about extensions? Should we have RFC before introducing them?

[peixin]

In D133558#3779568, @clementval wrote:

In D133558#3779517, @kiranchandramohan wrote:

I think we need any entry for these two non-standard intrinsics in flang/docs/Extensions.md.

What is the current stand about extensions? Should we have RFC before introducing them?

Some old workloads/applications use these two non-standard intrinsics. I hit this when building PNetCDF 1.11.2. Should I submit one RFC for this?

flang/lib/Evaluate/intrinsics.cpp

479 ↗

(On Diff #458978)

Thanks. Fixed.

[kiranchandramohan]

In D133558#3779568, @clementval wrote:

In D133558#3779517, @kiranchandramohan wrote:

I think we need any entry for these two non-standard intrinsics in flang/docs/Extensions.md.

What is the current stand about extensions? Should we have RFC before introducing them?

I think in general this is a good idea.

[PeteSteinfeld]

@klausler, has more experience in this area than anyone I know. It would be good to get his approval before submitting.

[peixin]

In D133558#3779996, @PeteSteinfeld wrote:

@klausler, has more experience in this area than anyone I know. It would be good to get his approval before submitting.

OK. Thanks. I will wait for @klausler 's review.

[peixin]

ping @klausler

[klausler]

Why do these need to be intrinsic procedures, and not just entry points in a standard library?

[peixin]

In D133558#3811763, @klausler wrote:

Why do these need to be intrinsic procedures, and not just entry points in a standard library?

1. What do you mean by "entry points in a standard library"？Does it mean the implementation of c_sizoof and sizeof? There is only one module "__Fortran_builtins" implicitly used.

2. GETARG and GET_COMMAND_ARGUMENT have different arguments. It seems they cannot be implemented using the same entry point.

[peixin]

In D133558#3811763, @klausler wrote:

Why do these need to be intrinsic procedures, and not just entry points in a standard library?

I get what you mean. Add IARGC as the alias of COMMAND_ARGUMENT_COUNT since they have the same interface. GETARG and GET_COMMAND_ARGUMENT have different interfaces. If they have the same entry point, the following test case will pass. However, it is non-conforming in gfortran.

PROGRAM test_get_command_argument
  INTEGER :: i
  CHARACTER(len=32) :: arg

  i = 0
  DO
    CALL GETARG(i, arg, length)
    IF (LEN_TRIM(arg) == 0) EXIT
    print *, i, " ", arg, " ", length
    i = i+1
  END DO
END PROGRAM

[klausler]

I am not suggesting that you simply establish some aliases.

IARGC and GETARG can be written in Fortran or C with code that calls the standard intrinsic procedures. Why not do that instead of creating new extension intrinsics?

[peixin]

In D133558#3813345, @klausler wrote:

I am not suggesting that you simply establish some aliases.

IARGC and GETARG can be written in Fortran or C with code that calls the standard intrinsic procedures. Why not do that instead of creating new extension intrinsics?

I am sorry that I am still confused about what you mean. Do you mean that Fortran users should handle this instead of supporting them in the compiler?

[klausler]

In D133558#3813507, @peixin wrote:

In D133558#3813345, @klausler wrote:

I am not suggesting that you simply establish some aliases.

IARGC and GETARG can be written in Fortran or C with code that calls the standard intrinsic procedures. Why not do that instead of creating new extension intrinsics?

I am sorry that I am still confused about what you mean. Do you mean that Fortran users should handle this instead of supporting them in the compiler?

No.

I mean that IARGC and GETARG can be defined in the runtime library without being intrinsics.

[peixin]

Implemented in runtime.

[peixin]

Add <cstdint> to fix CI fail.

[peixin]

Fix clang-format issue.

[peixin]

ping @klausler

[klausler]

flang/include/flang/Runtime/extensions.h

16

Would functions and subroutines ever have distinct name mangling conventions? I think that you could have just one macro here.

[peixin]

flang/include/flang/Runtime/extensions.h

16

Thanks. Fixed.

[klausler]

flang/runtime/extensions.cpp

19

Now that you are adding more definitions to the namespace Fortran::runtime, this comment should be moved down so that it applies to the definition of FLUSH only, not to the entire namespace.

[peixin]

Move the comments as suggested.

[klausler]

flang/runtime/extensions.cpp

35

n could be a reference.

arg could be const.

[peixin]

Thanks @klausler. Addressed the comments.

flang/runtime/extensions.cpp

35

Fix the *n to &n.

arg should not be const since Descriptor::Create requires it to be non-const. I hit the following error when I change it.

error: invalid conversion from ‘const void*’ to ‘void*’ [-fpermissive]
   36 |   Descriptor value{*Descriptor::Create(1, length, arg, 0)};
      |                                                   ^~~
      |                                                   |
      |                                                   const void*

flang/include/flang/Runtime/extensions.h

 //===-- include/flang/Runtime/extensions.h ----------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // These C-coded entry points with Fortran-mangled names implement legacy
 // extensions that will eventually be implemented in Fortran.
 
 #ifndef FORTRAN_RUNTIME_EXTENSIONS_H_
 #define FORTRAN_RUNTIME_EXTENSIONS_H_
 
-#define FORTRAN_SUBROUTINE_NAME(name) name##_
+#define FORTRAN_PROCEDURE_NAME(name) name##_
+
+#include <cstdint>
 
 extern "C" {
 
 // CALL FLUSH(n) antedates the Fortran 2003 FLUSH statement.
-void FORTRAN_SUBROUTINE_NAME(flush)(const int &unit);
+void FORTRAN_PROCEDURE_NAME(flush)(const int &unit);
+
+// GNU Fortran 77 compatibility function IARGC.
+std::int32_t FORTRAN_PROCEDURE_NAME(iargc)();
+
+// GNU Fortran 77 compatibility subroutine GETARG(N, ARG).
+void FORTRAN_PROCEDURE_NAME(getarg)(
+    std::int32_t &n, std::int8_t *arg, std::int64_t length);
 
 } // extern "C"
 #endif // FORTRAN_RUNTIME_EXTENSIONS_H_

flang/runtime/extensions.cpp

 //===-- runtime/extensions.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
 //
 //===----------------------------------------------------------------------===//
 
 // These C-coded entry points with Fortran-mangled names implement legacy
 // extensions that will eventually be implemented in Fortran.
 
 #include "flang/Runtime/extensions.h"
+#include "flang/Runtime/command.h"
+#include "flang/Runtime/descriptor.h"
 #include "flang/Runtime/io-api.h"
 
 extern "C" {
 
+namespace Fortran::runtime {
+namespace io {
 // SUBROUTINE FLUSH(N)
 //   FLUSH N
 // END
-namespace Fortran::runtime::io {
-void FORTRAN_SUBROUTINE_NAME(flush)(const int &unit) {
+void FORTRAN_PROCEDURE_NAME(flush)(const int &unit) {
   Cookie cookie{IONAME(BeginFlush)(unit, __FILE__, __LINE__)};
   IONAME(EndIoStatement)(cookie);
 }
-} // namespace Fortran::runtime::io
+} // namespace io
+
+// RESULT = IARGC()
+std::int32_t FORTRAN_PROCEDURE_NAME(iargc)() { return RTNAME(ArgumentCount)(); }
+
+// CALL GETARG(N, ARG)
+void FORTRAN_PROCEDURE_NAME(getarg)(
+    std::int32_t &n, std::int8_t *arg, std::int64_t length) {
+  Descriptor value{*Descriptor::Create(1, length, arg, 0)};
+  (void)RTNAME(GetCommandArgument)(
+      n, &value, nullptr, nullptr, __FILE__, __LINE__);
+}
+} // namespace Fortran::runtime
 } // extern "C"