[flang] Define & implement a lowering support API IsContiguous() in runtime

[klausler]

Summary

Create a new flang/runtime/support.cpp module to hold miscellaneous
runtime APIs to support lowering, and define an API IsContiguous() to
wrap the member function predicate Descriptor::IsContiguous().
And do a little clean-up of other API headers that don't need to expose
Runtime/descriptor.h.

[jeanPerier]

LGTM

flang/include/flang/Runtime/reduction.h

 //===-- include/flang/Runtime/reduction.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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines the API for the reduction transformational intrinsic functions.
 
 #ifndef FORTRAN_RUNTIME_REDUCTION_H_
 #define FORTRAN_RUNTIME_REDUCTION_H_
 
 #include "flang/Common/uint128.h"
-#include "flang/Runtime/descriptor.h"
 #include "flang/Runtime/entry-names.h"
+#include <cinttypes>
 #include <complex>
 #include <cstdint>
 
 namespace Fortran::runtime {
+
+class Descriptor;
+
 extern "C" {
 
 // Reductions that are known to return scalars have per-type entry
 // points.  These cover the cases that either have no DIM=
 // argument or have an argument rank of 1.  Pass 0 for no DIM=
 // or the value of the DIM= argument so that it may be checked.
 // The data type in the descriptor is checked against the expected
 // return type.

flang/include/flang/Runtime/support.h

+//===-- include/flang/Runtime/support.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
+//
+//===----------------------------------------------------------------------===//
+
+// Defines APIs for runtime support code for lowering.
+#ifndef FORTRAN_RUNTIME_SUPPORT_H_
+#define FORTRAN_RUNTIME_SUPPORT_H_
+
+#include "flang/Runtime/entry-names.h"
+
+namespace Fortran::runtime {
+
+class Descriptor;
+
+extern "C" {
+
+// Predicate: is the storage described by a Descriptor contiguous in memory?
+bool RTNAME(IsContiguous)(const Descriptor &);
+
+} // extern "C"
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_SUPPORT_H_

flang/include/flang/Runtime/transformational.h

 // These are naive allocating implementations; optimized forms that manipulate
 // pointer descriptors or that supply functional views of arrays remain to
 // be defined and may instead be part of lowering (see docs/ArrayComposition.md)
 // for details).
 
 #ifndef FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
 #define FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
 
-#include "flang/Runtime/descriptor.h"
 #include "flang/Runtime/entry-names.h"
-#include "flang/Runtime/memory.h"
+#include <cinttypes>
 
 namespace Fortran::runtime {
 
+class Descriptor;
+
 extern "C" {
 
 void RTNAME(Reshape)(Descriptor &result, const Descriptor &source,
     const Descriptor &shape, const Descriptor *pad = nullptr,
     const Descriptor *order = nullptr, const char *sourceFile = nullptr,
     int line = 0);
 
 void RTNAME(Cshift)(Descriptor &result, const Descriptor &source,

flang/runtime/CMakeLists.txt

add_flang_library(FortranRuntime
   numeric.cpp
   random.cpp
   reduction.cpp
   pointer.cpp
   product.cpp
   stat.cpp
   stop.cpp
   sum.cpp
+  support.cpp
   terminator.cpp
   time-intrinsic.cpp
   tools.cpp
   transformational.cpp
   type-code.cpp
   type-info.cpp
   unit.cpp
   unit-map.cpp
 
   LINK_LIBS
   FortranDecimal
 )

flang/runtime/reduction.cpp

 // operand types and shapes.
 //
 // DOT_PRODUCT, FINDLOC, MATMUL, SUM, and PRODUCT are in their own eponymous
 // source files.
 // NORM2, MAXLOC, MINLOC, MAXVAL, and MINVAL are in extrema.cpp.
 
 #include "flang/Runtime/reduction.h"
 #include "reduction-templates.h"
+#include "flang/Runtime/descriptor.h"
 #include <cinttypes>
 
 namespace Fortran::runtime {
 
 // IALL, IANY, IPARITY
 
 template <typename INTERMEDIATE> class IntegerAndAccumulator {
 public:

flang/runtime/support.cpp

+//===-- runtime/support.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/support.h"
+#include "flang/Runtime/descriptor.h"
+
+namespace Fortran::runtime {
+extern "C" {
+
+bool RTNAME(IsContiguous)(const Descriptor &descriptor) {
+  return descriptor.IsContiguous();
+}
+
+} // extern "C"
+} // namespace Fortran::runtime

flang/runtime/terminator.h

 //===-- runtime/terminator.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
 //
 //===----------------------------------------------------------------------===//
 
 // Termination of the image
 
 #ifndef FORTRAN_RUNTIME_TERMINATOR_H_
 #define FORTRAN_RUNTIME_TERMINATOR_H_
 
-#include "flang/Runtime/entry-names.h"
 #include <cstdarg>
 
 namespace Fortran::runtime {
 
 // A mixin class for statement-specific image error termination
 // for errors detected in the runtime library
 class Terminator {
 public:

flang/runtime/transformational.cpp

 // these cases as implying a hidden constraint, these implementations
 // work with arbitrary lower bounds.  This may be technically an extension
 // of the standard but it more likely to conform with its intent.
 
 #include "flang/Runtime/transformational.h"
 #include "copy.h"
 #include "terminator.h"
 #include "tools.h"
+#include "flang/Runtime/descriptor.h"
 #include <algorithm>
 
 namespace Fortran::runtime {
 
 // Utility for CSHIFT & EOSHIFT rank > 1 cases that determines the shift count
 // for each of the vector sections of the result.
 class ShiftControl {
 public: