[flang][runtime] Support L editing of Logical

[sunshaoce]

Summary

I tested gfortran and flang(old). https://godbolt.org/z/c89foro4G

[klausler]

The "Lw" edit descriptor already works in Flang. A bare "L" edit descriptor is an extension which you'll need to document. Also please ensure with tests that a bare "L" edit descriptor can be used in a FORMAT statement.

[sscalpone]

Please test with "L" embedded in a CHARACTER that is used as a format.

The extensions document is flang/docs/Extensions.md

[sunshaoce]

Address comments. Thanks!

[sunshaoce]

Modify test

[kiranchandramohan]

Thanks @sunshaoce for the patch. I have a comment about the location of the test.

flang/test/Driver/print-logical.f90

3 ↗

(On Diff #508933)

Execution tests are not put in the flang/test/Driver directory.

If you want to test execution then the best places are:

1. https://github.com/llvm/llvm-project/tree/main/flang/unittests/Runtime
2. https://github.com/llvm/llvm-test-suite/tree/main/Fortran/UnitTests

Please look at similar tests in this area.

[sunshaoce]

Add a unittest

[sunshaoce]

Rebase

[sunshaoce]

Rebase

[sunshaoce]

ping

[klausler]

Does this extension work with any other Fortran compiler?

[sunshaoce]

In D146989#4246205, @klausler wrote:

Does this extension work with any other Fortran compiler?

It seems that IFX and IFORT can only format logical types. For pgfortran, if someone can help test, it would be much appreciated.

[klausler]

In D146989#4246310, @sunshaoce wrote:

In D146989#4246205, @klausler wrote:

Does this extension work with any other Fortran compiler?

It seems that IFX and IFORT can only format logical types. For pgfortran, if someone can help test, it would be much appreciated.

It works for GNU Fortran, the Intel compilers, nvfortran, and XLF. It does not work with NAG. So it's worth doing.

[kiranchandramohan]

The 22.1 version of nvfortran worked for logicals and integers. It did not work for strings and reals.
gfortran's and nvfortran's interpretation of integers seems to be different for the L format.

BTW, thanks for moving the test to unittests/Runtime/LogicalFormatTest.cpp.

flang/docs/Extensions.md

* DEC `STRUCTURE`, `RECORD`, with '%FILL'; but `UNION`, and `MAP`
   are not yet supported throughout compilation, and elicit a
   "not yet implemented" message.
 * Structure field access with `.field`
 * `BYTE` as synonym for `INTEGER(KIND=1)`; but not when spelled `TYPE(BYTE)`.
 * When kind-param is used for REAL literals, allow a matching exponent letter
 * Quad precision REAL literals with `Q`
 * `X` prefix/suffix as synonym for `Z` on hexadecimal literals
 * `B`, `O`, `Z`, and `X` accepted as suffixes as well as prefixes
+* Support for using bare `L` in FORMAT statement
 * Triplets allowed in array constructors
 * `%LOC`, `%VAL`, and `%REF`
 * Leading comma allowed before I/O item list
 * Empty parentheses allowed in `PROGRAM P()`
 * Missing parentheses allowed in `FUNCTION F`
 * Cray based `POINTER(p,x)` and `LOC()` intrinsic (with `%LOC()` as
   an alias)
 * Arithmetic `IF`.  (Which branch should NaN take? Fall through?)

flang/runtime/edit-output.cpp

case 'B':
     return EditBOZOutput<1>(
         io, edit, reinterpret_cast<const unsigned char *>(&n), KIND);
   case 'O':
     return EditBOZOutput<3>(
         io, edit, reinterpret_cast<const unsigned char *>(&n), KIND);
   case 'Z':
     return EditBOZOutput<4>(
         io, edit, reinterpret_cast<const unsigned char *>(&n), KIND);
+  case 'L':
+    return EditLogicalOutput(io, edit, *reinterpret_cast<const char *>(&n));
   case 'A': // legacy extension
     return EditCharacterOutput(
         io, edit, reinterpret_cast<char *>(&n), sizeof n);
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with an INTEGER data item",
         edit.descriptor);
     return false;
return EditBOZOutput<3>(io_, edit,
         reinterpret_cast<const unsigned char *>(&x_),
         common::BitsForBinaryPrecision(common::PrecisionOfRealKind(KIND)) >> 3);
   case 'Z':
     return EditBOZOutput<4>(io_, edit,
         reinterpret_cast<const unsigned char *>(&x_),
         common::BitsForBinaryPrecision(common::PrecisionOfRealKind(KIND)) >> 3);
   case 'G':
     return Edit(EditForGOutput(edit));
+  case 'L':
+    return EditLogicalOutput(io_, edit, *reinterpret_cast<const char *>(&x_));
   case 'A': // legacy extension
     return EditCharacterOutput(
         io_, edit, reinterpret_cast<char *>(&x_), sizeof x_);
   default:
     if (edit.IsListDirected()) {
       return EditListDirectedOutput(edit);
     }
     io_.GetIoErrorHandler().SignalError(IostatErrorInFormat,
case 'B':
     return EditBOZOutput<1>(io, edit,
         reinterpret_cast<const unsigned char *>(x), sizeof(CHAR) * length);
   case 'O':
     return EditBOZOutput<3>(io, edit,
         reinterpret_cast<const unsigned char *>(x), sizeof(CHAR) * length);
   case 'Z':
     return EditBOZOutput<4>(io, edit,
         reinterpret_cast<const unsigned char *>(x), sizeof(CHAR) * length);
+  case 'L':
+    return EditLogicalOutput(io, edit, *reinterpret_cast<const char *>(x));
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with a CHARACTER data item",
         edit.descriptor);
     return false;
   }
   return EmitRepeated(io, ' ', std::max(0, width - len)) &&
       EmitEncoded(io, x, std::min(width, len));

flang/runtime/format-implementation.h

if (PeekNext() == '(') {
         }
       }
       if (!ok) {
         ReportBadFormat(context, "Unclosed DT(v_list) in FORMAT", start);
         return std::nullopt;
       }
     }
   }
-  if (edit.descriptor == 'A') { // width is optional for A[w]
+  if (edit.descriptor == 'A' || edit.descriptor == 'L') {
+    // width is optional for A[w] or L[w]
     auto ch{PeekNext()};
     if (ch >= '0' && ch <= '9') {
       edit.width = GetIntField(context);
     }
   } else if (edit.descriptor != DataEdit::DefinedDerivedType) {
     edit.width = GetIntField(context);
   }
   if constexpr (std::is_base_of_v<InputStatementState, CONTEXT>) {

flang/unittests/Runtime/CMakeLists.txt

 add_flang_unittest(FlangRuntimeTests
   Allocatable.cpp
   ArrayConstructor.cpp
   BufferTest.cpp
   CharacterTest.cpp
   CommandTest.cpp
   Complex.cpp
   CrashHandlerFixture.cpp
   Derived.cpp
   ExternalIOTest.cpp
   Format.cpp
   Inquiry.cpp
   ListInputTest.cpp
+  LogicalFormatTest.cpp
   Matmul.cpp
   MatmulTranspose.cpp
   MiscIntrinsic.cpp
   Namelist.cpp
   Numeric.cpp
   NumericalFormatTest.cpp
   Pointer.cpp
   Ragged.cpp

flang/unittests/Runtime/LogicalFormatTest.cpp

+//===-- flang/unittests/Runtime/LogicalFormatTest.cpp -----------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "CrashHandlerFixture.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/io-api.h"
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <gtest/gtest.h>
+#include <tuple>
+
+using namespace Fortran::runtime;
+using namespace Fortran::runtime::io;
+
+TEST(IOApiTests, LogicalFormatTest) {
+  static constexpr int bufferSize{29};
+  char buffer[bufferSize];
+
+  // Create format for all types and values to be written
+  const char *format{"(L,L3,I3,L2,L2,I3,L2,A3,L2,L,F4.1,L2)"};
+  auto cookie{IONAME(BeginInternalFormattedOutput)(
+      buffer, bufferSize, format, std::strlen(format))};
+
+  // Write string, integer, and logical values to buffer
+  IONAME(OutputLogical)(cookie, true);
+  IONAME(OutputLogical)(cookie, false);
+  IONAME(OutputInteger64)(cookie, 6);
+  IONAME(OutputInteger32)(cookie, 22);
+  IONAME(OutputInteger32)(cookie, 0);
+  IONAME(OutputInteger32)(cookie, -2);
+  IONAME(OutputCharacter)(cookie, "ABC", 3);
+  IONAME(OutputCharacter)(cookie, "AB", 2);
+  IONAME(OutputReal64)(cookie, 0.0);
+  IONAME(OutputCharacter)(cookie, "", 0);
+  IONAME(OutputReal32)(cookie, 2.3);
+  IONAME(OutputReal32)(cookie, 2.3);
+
+  // Ensure IO succeeded
+  auto status{IONAME(EndIoStatement)(cookie)};
+  ASSERT_EQ(status, 0) << "logical format: '" << format << "' failed, status "
+                       << static_cast<int>(status);
+
+  // Ensure final buffer matches expected string output
+  static const std::string expect{"T  F  6 T F -2 T AB FF 2.3 T"};
+
+  // expect.size() == bufferSize - 1
+  std::string bufferStr = std::string(buffer, bufferSize - 1);
+  ASSERT_TRUE(expect == bufferStr)
+      << "Expected '" << expect << "', got '" << bufferStr << "'";
+}