Revert "[flang] Add ETIME runtime and lowering intrinsics implementation" (llvm#92354)

Reverts llvm#90578

This broke the premerge linux buildbot.

Author: joker-eph

etime-function.mlir

@@ -916,55 +916,3 @@ used in constant expressions have currently no folding support at all.
   - If a condition occurs that would assign a nonzero value to `CMDSTAT` but the `CMDSTAT` variable is not present, error termination is initiated.
     - On POSIX-compatible systems, the child process (async process) will be terminated with no effect on the parent process (continues).
     - On Windows, error termination is not initiated.
-
-### Non-Standard Intrinsics: ETIME
-
-#### Description
-`ETIME(VALUES, TIME)` returns the number of seconds of runtime since the start of the process’s execution in *TIME*. *VALUES* returns the user and system components of this time in `VALUES(1)` and `VALUES(2)` respectively. *TIME* is equal to `VALUES(1) + VALUES(2)`.
-
-On some systems, the underlying timings are represented using types with sufficiently small limits that overflows (wrap around) are possible, such as 32-bit types. Therefore, the values returned by this intrinsic might be, or become, negative, or numerically less than previous values, during a single run of the compiled program.
-
-This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.
-
-*VALUES* and *TIME* are `INTENT(OUT)` and provide the following:
-
-
-|               |                                   |
-|---------------|-----------------------------------|
-| `VALUES(1)`   | User time in seconds.             |
-| `VALUES(2)`   | System time in seconds.           |
-| `TIME`        | Run time since start in seconds.  |
-
-#### Usage and Info
-
-- **Standard:** GNU extension
-- **Class:** Subroutine, function
-- **Syntax:** `CALL ETIME(VALUES, TIME)`
-- **Arguments:**
-- **Return value** Elapsed time in seconds since the start of program execution.
-
-| Argument   | Description                                                           |
-|------------|-----------------------------------------------------------------------|
-| `VALUES`   | The type shall be REAL(4), DIMENSION(2).                              |
-| `TIME`     | The type shall be REAL(4).                                            |
-
-#### Example
-Here is an example usage from [Gfortran ETIME](https://gcc.gnu.org/onlinedocs/gfortran/ETIME.html)
-```Fortran
-program test_etime
-    integer(8) :: i, j
-    real, dimension(2) :: tarray
-    real :: result
-    call ETIME(tarray, result)
-    print *, result
-    print *, tarray(1)
-    print *, tarray(2)   
-    do i=1,100000000    ! Just a delay
-        j = i * i - i
-    end do
-    call ETIME(tarray, result)
-    print *, result
-    print *, tarray(1)
-    print *, tarray(2)
-end program test_etime
-```

flang/docs/Intrinsics.md

@@ -222,8 +222,6 @@ struct IntrinsicLibrary {
   fir::ExtendedValue genEoshift(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   void genExit(llvm::ArrayRef<fir::ExtendedValue>);
   void genExecuteCommandLine(mlir::ArrayRef<fir::ExtendedValue> args);
-  fir::ExtendedValue genEtime(std::optional<mlir::Type>,
-                              mlir::ArrayRef<fir::ExtendedValue> args);
   mlir::Value genExponent(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genExtendsTypeOf(mlir::Type,
                                       llvm::ArrayRef<fir::ExtendedValue>);
@@ -402,10 +400,8 @@ struct IntrinsicLibrary {
   using ElementalGenerator = decltype(&IntrinsicLibrary::genAbs);
   using ExtendedGenerator = decltype(&IntrinsicLibrary::genLenTrim);
   using SubroutineGenerator = decltype(&IntrinsicLibrary::genDateAndTime);
-  /// The generator for intrinsic that has both function and subroutine form.
-  using DualGenerator = decltype(&IntrinsicLibrary::genEtime);
-  using Generator = std::variant<ElementalGenerator, ExtendedGenerator,
-                                 SubroutineGenerator, DualGenerator>;
+  using Generator =
+      std::variant<ElementalGenerator, ExtendedGenerator, SubroutineGenerator>;
 
   /// All generators can be outlined. This will build a function named
   /// "fir."+ <generic name> + "." + <result type code> and generate the
@@ -446,10 +442,6 @@ struct IntrinsicLibrary {
                               llvm::ArrayRef<mlir::Value> args);
   mlir::Value invokeGenerator(SubroutineGenerator generator,
                               llvm::ArrayRef<mlir::Value> args);
-  mlir::Value invokeGenerator(DualGenerator generator,
-                              llvm::ArrayRef<mlir::Value> args);
-  mlir::Value invokeGenerator(DualGenerator generator, mlir::Type resultType,
-                              llvm::ArrayRef<mlir::Value> args);
 
   /// Get pointer to unrestricted intrinsic. Generate the related unrestricted
   /// intrinsic if it is not defined yet.

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

@@ -44,8 +44,6 @@ void genDateAndTime(fir::FirOpBuilder &, mlir::Location,
                     std::optional<fir::CharBoxValue> date,
                     std::optional<fir::CharBoxValue> time,
                     std::optional<fir::CharBoxValue> zone, mlir::Value values);
-void genEtime(fir::FirOpBuilder &builder, mlir::Location loc,
-              mlir::Value values, mlir::Value time);
 
 void genRandomInit(fir::FirOpBuilder &, mlir::Location, mlir::Value repeatable,
                    mlir::Value imageDistinct);

flang/include/flang/Optimizer/Builder/Runtime/Intrinsics.h

@@ -43,9 +43,6 @@ void RTNAME(DateAndTime)(char *date, std::size_t dateChars, char *time,
     const char *source = nullptr, int line = 0,
     const Descriptor *values = nullptr);
 
-void RTNAME(Etime)(const Descriptor *values, const Descriptor *time,
-    const char *sourceFile, int line);
-
 } // extern "C"
 } // namespace Fortran::runtime
 #endif // FORTRAN_RUNTIME_TIME_INTRINSIC_H_

flang/include/flang/Runtime/time-intrinsic.h

@@ -454,10 +454,6 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
     {"erf", {{"x", SameReal}}, SameReal},
     {"erfc", {{"x", SameReal}}, SameReal},
     {"erfc_scaled", {{"x", SameReal}}, SameReal},
-    {"etime",
-        {{"values", TypePattern{RealType, KindCode::exactKind, 4}, Rank::vector,
-            Optionality::required, common::Intent::Out}},
-        TypePattern{RealType, KindCode::exactKind, 4}},
     {"exp", {{"x", SameFloating}}, SameFloating},
     {"exp", {{"x", SameFloating}}, SameFloating},
     {"exponent", {{"x", AnyReal}}, DefaultInt},
@@ -1346,12 +1342,6 @@ static const IntrinsicInterface intrinsicSubroutine[]{
             {"values", AnyInt, Rank::vector, Optionality::optional,
                 common::Intent::Out}},
         {}, Rank::elemental, IntrinsicClass::impureSubroutine},
-    {"etime",
-        {{"values", TypePattern{RealType, KindCode::exactKind, 4}, Rank::vector,
-             Optionality::required, common::Intent::Out},
-            {"time", TypePattern{RealType, KindCode::exactKind, 4},
-                Rank::scalar, Optionality::required, common::Intent::Out}},
-        {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"execute_command_line",
         {{"command", DefaultChar, Rank::scalar},
             {"wait", AnyLogical, Rank::scalar, Optionality::optional},
@@ -2494,7 +2484,6 @@ class IntrinsicProcTable::Implementation {
   bool IsIntrinsic(const std::string &) const;
   bool IsIntrinsicFunction(const std::string &) const;
   bool IsIntrinsicSubroutine(const std::string &) const;
-  bool IsDualIntrinsic(const std::string &) const;
 
   IntrinsicClass GetIntrinsicClass(const std::string &) const;
   std::string GetGenericIntrinsicName(const std::string &) const;
@@ -2556,17 +2545,6 @@ bool IntrinsicProcTable::Implementation::IsIntrinsic(
     const std::string &name) const {
   return IsIntrinsicFunction(name) || IsIntrinsicSubroutine(name);
 }
-bool IntrinsicProcTable::Implementation::IsDualIntrinsic(
-    const std::string &name) const {
-  // Collection for some intrinsics with function and subroutine form,
-  // in order to pass the semantic check.
-  static const std::string dualIntrinsic[]{{"etime"}};
-
-  return std::find_if(std::begin(dualIntrinsic), std::end(dualIntrinsic),
-             [&name](const std::string &dualName) {
-               return dualName == name;
-             }) != std::end(dualIntrinsic);
-}
 
 IntrinsicClass IntrinsicProcTable::Implementation::GetIntrinsicClass(
     const std::string &name) const {
@@ -3105,7 +3083,7 @@ std::optional<SpecificCall> IntrinsicProcTable::Implementation::Probe(
         return specificCall;
       }
     }
-    if (IsIntrinsicFunction(call.name) && !IsDualIntrinsic(call.name)) {
+    if (IsIntrinsicFunction(call.name)) {
       context.messages().Say(
           "Cannot use intrinsic function '%s' as a subroutine"_err_en_US,
           call.name);
@@ -3240,7 +3218,7 @@ std::optional<SpecificCall> IntrinsicProcTable::Implementation::Probe(
   }
 
   if (specificBuffer.empty() && genericBuffer.empty() &&
-      IsIntrinsicSubroutine(call.name) && !IsDualIntrinsic(call.name)) {
+      IsIntrinsicSubroutine(call.name)) {
     context.messages().Say(
         "Cannot use intrinsic subroutine '%s' as a function"_err_en_US,
         call.name);

flang/lib/Evaluate/intrinsics.cpp

@@ -35,7 +35,6 @@
 #include "flang/Optimizer/Builder/Runtime/Stop.h"
 #include "flang/Optimizer/Builder/Runtime/Transformational.h"
 #include "flang/Optimizer/Builder/Todo.h"
-#include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/Support/FatalError.h"
@@ -50,7 +49,6 @@
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
-#include <mlir/IR/Value.h>
 #include <optional>
 
 #define DEBUG_TYPE "flang-lower-intrinsic"
@@ -224,10 +222,6 @@ static constexpr IntrinsicHandler handlers[]{
        {"boundary", asBox, handleDynamicOptional},
        {"dim", asValue}}},
      /*isElemental=*/false},
-    {"etime",
-     &I::genEtime,
-     {{{"values", asBox}, {"time", asBox}}},
-     /*isElemental=*/false},
     {"execute_command_line",
      &I::genExecuteCommandLine,
      {{{"command", asBox},
@@ -1688,24 +1682,6 @@ IntrinsicLibrary::genElementalCall<IntrinsicLibrary::SubroutineGenerator>(
   return mlir::Value();
 }
 
-template <>
-fir::ExtendedValue
-IntrinsicLibrary::genElementalCall<IntrinsicLibrary::DualGenerator>(
-    DualGenerator generator, llvm::StringRef name, mlir::Type resultType,
-    llvm::ArrayRef<fir::ExtendedValue> args, bool outline) {
-  assert(resultType.getImpl() && "expect elemental intrinsic to be functions");
-
-  for (const fir::ExtendedValue &arg : args)
-    if (!arg.getUnboxed() && !arg.getCharBox())
-      // fir::emitFatalError(loc, "nonscalar intrinsic argument");
-      crashOnMissingIntrinsic(loc, name);
-  if (outline)
-    return outlineInExtendedWrapper(generator, name, resultType, args);
-
-  return std::invoke(generator, *this, std::optional<mlir::Type>{resultType},
-                     args);
-}
-
 static fir::ExtendedValue
 invokeHandler(IntrinsicLibrary::ElementalGenerator generator,
               const IntrinsicHandler &handler,
@@ -1749,22 +1725,6 @@ invokeHandler(IntrinsicLibrary::SubroutineGenerator generator,
   return mlir::Value{};
 }
 
-static fir::ExtendedValue
-invokeHandler(IntrinsicLibrary::DualGenerator generator,
-              const IntrinsicHandler &handler,
-              std::optional<mlir::Type> resultType,
-              llvm::ArrayRef<fir::ExtendedValue> args, bool outline,
-              IntrinsicLibrary &lib) {
-  if (handler.isElemental)
-    return lib.genElementalCall(generator, handler.name, mlir::Type{}, args,
-                                outline);
-  if (outline)
-    return lib.outlineInExtendedWrapper(generator, handler.name, resultType,
-                                        args);
-
-  return std::invoke(generator, lib, resultType, args);
-}
-
 std::pair<fir::ExtendedValue, bool>
 IntrinsicLibrary::genIntrinsicCall(llvm::StringRef specificName,
                                    std::optional<mlir::Type> resultType,
@@ -1860,34 +1820,6 @@ IntrinsicLibrary::invokeGenerator(SubroutineGenerator generator,
   return {};
 }
 
-mlir::Value
-IntrinsicLibrary::invokeGenerator(DualGenerator generator,
-                                  llvm::ArrayRef<mlir::Value> args) {
-  llvm::SmallVector<fir::ExtendedValue> extendedArgs;
-  for (mlir::Value arg : args)
-    extendedArgs.emplace_back(toExtendedValue(arg, builder, loc));
-  std::invoke(generator, *this, std::optional<mlir::Type>{}, extendedArgs);
-  return {};
-}
-
-mlir::Value
-IntrinsicLibrary::invokeGenerator(DualGenerator generator,
-                                  mlir::Type resultType,
-                                  llvm::ArrayRef<mlir::Value> args) {
-  llvm::SmallVector<fir::ExtendedValue> extendedArgs;
-  for (mlir::Value arg : args)
-    extendedArgs.emplace_back(toExtendedValue(arg, builder, loc));
-
-  if (resultType.getImpl() == nullptr) {
-    // TODO:
-    assert(false && "result type is null");
-  }
-
-  auto extendedResult = std::invoke(
-      generator, *this, std::optional<mlir::Type>{resultType}, extendedArgs);
-  return toValue(extendedResult, builder, loc);
-}
-
 //===----------------------------------------------------------------------===//
 // Intrinsic Procedure Mangling
 //===----------------------------------------------------------------------===//
@@ -3303,37 +3235,6 @@ void IntrinsicLibrary::genExecuteCommandLine(
                                       exitstatBox, cmdstatBox, cmdmsgBox);
 }
 
-// ETIME
-fir::ExtendedValue
-IntrinsicLibrary::genEtime(std::optional<mlir::Type> resultType,
-                           llvm::ArrayRef<fir::ExtendedValue> args) {
-  assert((args.size() == 2 && !resultType.has_value()) ||
-         (args.size() == 1 && resultType.has_value()));
-
-  mlir::Value values = fir::getBase(args[0]);
-  if (resultType.has_value()) {
-    // function form
-    if (!values)
-      fir::emitFatalError(loc, "expected VALUES parameter");
-
-    auto timeAddr = builder.createTemporary(loc, *resultType);
-    auto timeBox = builder.createBox(loc, timeAddr);
-    fir::runtime::genEtime(builder, loc, values, timeBox);
-    return builder.create<fir::LoadOp>(loc, timeAddr);
-  } else {
-    // subroutine form
-    mlir::Value time = fir::getBase(args[1]);
-    if (!values)
-      fir::emitFatalError(loc, "expected VALUES parameter");
-    if (!time)
-      fir::emitFatalError(loc, "expected TIME parameter");
-
-    fir::runtime::genEtime(builder, loc, values, time);
-    return {};
-  }
-  return {};
-}
-
 // EXIT
 void IntrinsicLibrary::genExit(llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 1);

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

@@ -106,20 +106,6 @@ void fir::runtime::genDateAndTime(fir::FirOpBuilder &builder,
   builder.create<fir::CallOp>(loc, callee, args);
 }
 
-void fir::runtime::genEtime(fir::FirOpBuilder &builder, mlir::Location loc,
-                            mlir::Value values, mlir::Value time) {
-  auto runtimeFunc = fir::runtime::getRuntimeFunc<mkRTKey(Etime)>(loc, builder);
-  mlir::FunctionType runtimeFuncTy = runtimeFunc.getFunctionType();
-
-  mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
-  mlir::Value sourceLine =
-      fir::factory::locationToLineNo(builder, loc, runtimeFuncTy.getInput(3));
-
-  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
-      builder, loc, runtimeFuncTy, values, time, sourceFile, sourceLine);
-  builder.create<fir::CallOp>(loc, runtimeFunc, args);
-}
-
 void fir::runtime::genRandomInit(fir::FirOpBuilder &builder, mlir::Location loc,
                                  mlir::Value repeatable,
                                  mlir::Value imageDistinct) {