Flang implementation for COMPILER_VERSION and COMPILER_OPTIONS intrinsics

[hussainjk]

Summary

This revision implements the Fortran intrinsic procedures COMPILER_VERSION and COMPILER_OPTIONS from the iso_fortran_env module.
To be able to set the COMPILER_OPTIONS string according to the original compiler driver invocation, a string is passed to the frontend driver using the environment variable FLANG_COMPILER_OPTIONS_STRING, for lack of a better mechanism.

Fixes #59233

[PeteSteinfeld]

There's something wonky about this patch. I was unable to apply it against the latest sources. Can you please rebase?

[ktras]

Is there a test you could add to this patch to show that the changes work as expected?

[klausler]

flang/include/flang/Common/Version.h

23

Don't indent the contents of a namespace.

Use capitalized names.

flang/lib/Lower/IntrinsicCall.cpp

747 ↗

(On Diff #484735)

This intrinsic function must be folded during semantics, not implemented in code generation.

[rouson]

flang/lib/Lower/IntrinsicCall.cpp

747 ↗

(On Diff #484735)

@klausler could you explain how one knows whether an intrinsic function must be folded during semantics or implemented in code generation?

[klausler]

flang/lib/Lower/IntrinsicCall.cpp

747 ↗

(On Diff #484735)

F'2018 subclause "10.1.12 Constant expression" reads:

A constant expression is an expression with limitations that make it suitable for use as a kind type parameter, initializer, or named constant. It is an expression in which each operation is intrinsic, and each primary is ...

... (6) a reference to a standard intrinsic function that is transformational, other than COMMAND_ARGUMENT_COUNT, GET_TEAM, NULL, NUM_IMAGES, TEAM_NUMBER, THIS_IMAGE, or TRANSFER, where each argument is a constant expression,

16.10.2.7 COMPILER_VERSION ( )
1 Description. Processor-dependent string identifying the program translation phase.
2 Class. Transformational function.
3 Argument. None.

A reference to COMPILER_VERSION() is a primary that is a reference to a standard intrinsic transformational function other than COMMAND_ARGUMENT_COUNT, GET_TEAM, NULL, NUM_IMAGES, TEAM_NUMBER, THIS_IMAGE, or TRANSFER, and it has no argument that is not a constant expression, so it satisfies the requirements of point (6) in the definition of a constant expression, and so it is a constant expression.

[hussainjk]

Re-implemented compiler_version, and implemented compiler_options, using intrinsic folding pass.

[awarzynski]

Please add a test.

flang/include/flang/Frontend/CompilerInvocation.h

86

This doesn't feel right. One of the task of the frontend driver is to parse command line arguments and split them into various fields in this class. There should be no dedicated field for ALL arguments (on top of other fields).

flang/lib/Frontend/CompilerInvocation.cpp

1052

Wouldn't this forward all command line arguments to set_compilerOptionsString?

[ktras]

flang/lib/Evaluate/intrinsics.cpp

2156–2157

Please delete this line of commented out code.

[hussainjk]

Rebasing and formatting.

[hussainjk]

flang/lib/Frontend/CompilerInvocation.cpp

1052

Pretty much. It wasn't clear to me to what extent should compiler_options be reporting command-line flags. Should it be more narrow?

[awarzynski]

The summary states "Implementation for COMPILER_VERSION intrinsic procedure", but it looks like this patch implements COMPILER_VERSION and COMPILER_OPTIONS. Please, could you update it accordingly? Also, please add the missing tests.

flang/lib/Frontend/CompilerInvocation.cpp

1052

I think that we are referring to two different things:

• IIUC, you are referring to COMPILER_OPTIONS Fortran intrinsic,
• I am referring to the design of the Flang driver and various implementation details, e.g. the fact that that the CompilerInvocation encapsulates a compiler invocation and that it groups compilation options into various sets, e.g. [[ flang/lib/Frontend/CompilerInvocation.cpp | parserOpts ]].

Please add a comment to explain that all compiler options are forwarded to the semantics context in order to implement COMPILER_OPTIONS. Also, rather than duplicating compiler options in commandLineArgs, please use the existing fields in CompilerInvocaiton.

[hussainjk]

Adding test for compiler_version.

[hussainjk]

flang/lib/Frontend/CompilerInvocation.cpp

1052

So I did some tinkering around regarding this. The problem with the compiler option groupings is that they are encapsulated into a few different nonstandard classes, for which there is no method to iterate through, and which don't all have methods to retrieve a command-line string representation. So setting the compiler options string would then involve a lot of lines manually going through struct fields and appending option strings and corresponding values, which is a lot more fragile than just storing the original string. It seems like the current way should be preferred for maintainability.

[kiranchandramohan]

Thanks for this patch. This patch fixes the following issue. If you can add `Fixes #59233 then the issue will automatically be closed when you submit.
https://github.com/llvm/llvm-project/issues/59233
You can consider using the test in the issue.

flang/lib/Frontend/CompilerInvocation.cpp

1052

It is not clear to me what options should be made visible to the user. Is it the options provided in the command line or the internal options that are used?

The current handling in the frontend driver captures the internal options and not the original options entered by the user. If we want the command line options then the compiler driver has this information and should pass it to the frontend driver as a string.

For eg: Currently, the following output is produced, which is not what the user provided.

$ ./bin/flang-new -flang-experimental-exec -O3 co.f90                                                                           
$ ./a.out 
 -triple aarch64-unknown-linux-gnu -emit-obj -fcolor-diagnostics -mrelocation-model pic -pic-level 2 -pic-is-pie -target-cpu generic -target-feature +neon -target-feature +v8a -O3 -o /tmp/co-cd57e2.o -x f95-cpp-input co.f90

I see that other compilers also provide some internal options but fewer.

$ gfortran -O3 co.f90 
$ ./a.out 
 -mlittle-endian -mabi=lp64 -O3 -fpre-include=/usr/include/finclude/math-vector-fortran.h

$ nvfortran -O3 co.f90 
$ ./a.out 
 co.f90 -O3 -Mvect=simd -Mflushz -Mcache_align -Mrecip-div -Mfactorize

flang/test/Evaluate/compiler_version.f90

2

We generally do not have emit-llvm tests here.

You can test this with either -fdebug-unparse or -fdebug-dump-parse-tree tests.

Please add a test for both compiler_version and compiler_options.

[tschuett]

flang/include/flang/Common/Version.h

23

Subversion should be Git.

30

Upstream LLVM is a monorepo. I don't believe that having flang and llvm in different repositories is supported.

[klausler]

flang/include/flang/Common/Version.h

30

Out-of-tree builds work just fine.

[hussainjk]

Rewriting compiler_version test per review comments.

[hussainjk]

Minor typo fix.

[hussainjk]

Re-implemented compiler_options to be based on the options passed in by the user. Added a test for compiler_options.

[hussainjk]

fixing build bugs.

[hussainjk]

flang/lib/Frontend/CompilerInvocation.cpp

1052

I rewrote this so that the compiler options string is instead set to the original command line invocation made by the user.
This information needs to be passed from the parent frontend process to the internal cc1 process which is subsequently launched. Currently it is doing this by setting an environment variable, but it could also be done with a command-line option passed to the cc1 stage, if that would be preferred.

Right now it is not including any internal expanded options, but that should be easy to do if we identify some that should be.

[kiranchandramohan]

flang/lib/Frontend/CompilerInvocation.cpp

882

Not sure whether this style of using environment variables in the Driver to pass options between the Flang driver and the Flang frontend driver is OK. I was hoping you will pass it as an option with a string value to the Flang frontend driver.
-fc1 -co "<OPTIONS>"``

Please wait for @awarzynski for an opinion.

1052

Thanks @hussainjk. See comment inline regarding using environment variables for passing info.

[awarzynski]

@hussainjk , thanks for the updates!

The idea of using an environment variable to pass something from flang-new to flang-new -fc1 bypasses the "separation of concerns" in the driver design:

• flang-new drives the frontend driver (flang-new -fc1), assembler and linker (i.e. creates invocations of these tools).
• Once invoked, the frontend driver (flang-new -fc1) has no access to the compiler driver invocation - it doesn't need to. Indeed, why would the frontend be concerned with e.g. linker flags?

Passing it as a string, as @kiranchandramohan suggested, would help avoid requiring env variables. However, it would pollute the frontend driver invocation (flang-new -fc1 <args>) that people may want to use for debugging. I wish that we could avoid both, but I have no better suggestions. IMHO, this is inherently a Fortran issue. I am not a language expert, but do feel that COMPILER_OPTIONS is trying to expose information that belongs in the toolchain rather than language implementation.

Personally I am leaning towards accepting the approach with env variables. @kiranchandramohan, would that work? @hussainjk , could you add comments discouraging people from using similar mechanism for other things? Hopefully this is the only exception that we need to make.

Also, @hussainjk, your effort is much appreciated, thank you for experimenting with different approaches!

flang/lib/Frontend/CompilerInvocation.cpp

882

883–884

Please document that in one case the compiler will use "compiler driver" options (flang-new) and in the other "frontend driver" options (flang-new -fc1).

flang/test/Evaluate/compiler_options.f90

1 ↗

(On Diff #523818)

Similar test without -fc1 would be helpful too. Also, could you verify that with flang-new the user will only see the user specified options (so no flang-new -fc1 options)?

flang/tools/flang-driver/fc1_main.cpp

53–54

This change is no longer required, right?

[hussainjk]

Addressing some review comments.

[hussainjk]

flang/tools/flang-driver/fc1_main.cpp

53–54

In the case when the frontend driver is invoked directly (and hence no env var), createFromArgs will set the COMPILER_OPTIONS string based on the actual command line, but it needs to be passed argv0 because it otherwise only gets the rest of argv.

[hussainjk]

flang/test/Evaluate/compiler_options.f90

1 ↗

(On Diff #523818)

It seems that -fc1 is necessary for -fdebug-unparse. So I could do this but using -emit-llvm. Thoughts, @kiranchandramohan?

[hussainjk]

@awarzynski thanks! I was also concerned about polluting the frontend invocation, as well as the scope creep of adding new command line option definitions.

[awarzynski]

Thanks again for the updates. This is heading in the right direction, but I'd like to see the documentation for introducing FLANG_COMPILER_OPTIONS_STRING and compilerOptionsString a bit more refined. See my suggestions inline.

flang/include/flang/Frontend/CompilerInvocation.h

85

Naming is hard and I don't claim my suggestion is perfect. My main point is that there's no need to include variable type in variable's name ;-)

Please also add a comment that explains what this string is for.

flang/lib/Frontend/CompilerInvocation.cpp

880

881–883

I think that this comment is missing some detail. Please see my suggestion and feel free to re-use and/or edit.

flang/test/Evaluate/compiler_options.f90

7 ↗

(On Diff #524153)

?

1 ↗

(On Diff #523818)

You can add a test with -emit-llvm in flang/test/Driver. Just document that that would be specifically to test communicating COMPILER_OPTIONS from flang-new to flang-new -fc1.

flang/tools/flang-driver/driver.cpp

140–141

Please be more specific.

1. I am aware of COMPILER_OPTIONS Fortran intrinsic and compilerOptionsString string in Flang's CompilerInvocation.h (that I suggested to be renamed). Which one is it?
2. Why is this env variable being passed to the frontend driver like this? Please document that this is specifically for the COMPILER_OPTIONS intrinsic and that there is no other mechanism to communicate the original invocation between the compiler and the frontend drivers.

We are making an exception here to avoid excessive polution of the frontend invocation.

Not quite. An exception is being made, because we haven't been able to identify a better alternative to implement COMPILER_OPTIONS intrinsics. We could, instead, add an additional option to the frontend driver invocation, but that wouldn't be 100% problem-free.

How about:

Set the environment variable, FLANG_COMPILER_OPTIONS_STRING, to contain all the compiler options. This is intended for the frontend driver, flang-new -fc1, to enable the implementation of the COMPILER_OPTIONS intrinsic. To this end, the frontend driver requires the list of the original compiler options, which is not available through other means.
TODO: This way of passing information between the compiler and frontend drivers is discouraged. We should find a better way not involving env variables.

146

IMHO, compilerOptsAsOneString would be more descriptive. In either way, please adhere to the coding style and use camelCase.

flang/tools/flang-driver/fc1_main.cpp

53–54

Please, could you maintain consistency with Clang and add a default value for argv0: https://github.com/llvm/llvm-project/blob/7ca1bcbc6043b7ab4635f04746d1b9480960e384/clang/include/clang/Frontend/CompilerInvocation.h#L207-L210.

[awarzynski]

flang/lib/Frontend/CompilerInvocation.cpp

820

[tschuett]

Clang and other tools use response files when the command line gets too long, e.g.
https://reviews.llvm.org/D4897#change-Me6ZMDruqhhS

Note the @

[tschuett]

flang-* seems to support response files:
https://github.com/llvm/llvm-project/blob/8a4e3675d88ecd0413d89dea1e3578a4696b05da/flang/tools/flang-driver/driver.cpp#L96

[hussainjk]

Addressing review comments.

[hussainjk]

Addressing review comments.

[awarzynski]

The driver logic LGTM, thank you for addressing my comments (I've added one more formatting suggestion)! Please wait a day or two before landing this - I've only really looked at the bits I'm familiar with (i.e. the driver).

Also, could you update the summary/commit message. I would appreciate if you could "introduce" the rationale for adding the env variable. Thank you!

flang/include/flang/Frontend/CompilerInvocation.h

85–87

[klausler]

The out-of-tree build is now broken and there are a number of style problems with a new source file; see #general on Slack. Please address the out-of-tree build failure in a timely manner.

[sscalpone]

flang/test/Driver/compiler_options.f90

13

Why close?

[klausler]

The out-of-tree build bot is still failing.

[klausler]

Scratch that; the out-of-tree build bot has now built successfully with your latest commit. Thank you for that.

Please clean up the other issues that I enumerated on Slack.

flang/include/flang/Common/Version.h

+//===- Version.h - Flang Version Number ---------------------*- Fortran -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Defines version macros and version-related utility functions
+/// for Flang.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FLANG_COMMON_VERSION_H
+#define LLVM_FLANG_COMMON_VERSION_H
+
+#include "flang/Version.inc"
+#include "llvm/ADT/StringRef.h"
+
+namespace Fortran::common {
+/// Retrieves the repository path (e.g., Git path) that
+/// identifies the particular Flang branch, tag, or trunk from which this
+/// Flang was built.
+std::string getFlangRepositoryPath();
+
+/// Retrieves the repository path from which LLVM was built.
+///
+/// This supports LLVM residing in a separate repository from flang.
+std::string getLLVMRepositoryPath();
+
+/// Retrieves the repository revision number (or identifier) from which
+/// this Flang was built.
+std::string getFlangRevision();
+
+/// Retrieves the repository revision number (or identifier) from which
+/// LLVM was built.
+///
+/// If Flang and LLVM are in the same repository, this returns the same
+/// string as getFlangRevision.
+std::string getLLVMRevision();
+
+/// Retrieves the full repository version that is an amalgamation of
+/// the information in getFlangRepositoryPath() and getFlangRevision().
+std::string getFlangFullRepositoryVersion();
+
+/// Retrieves a string representing the complete flang version,
+/// which includes the flang version number, the repository version,
+/// and the vendor tag.
+std::string getFlangFullVersion();
+
+/// Like getFlangFullVersion(), but with a custom tool name.
+std::string getFlangToolFullVersion(llvm::StringRef ToolName);
+} // namespace Fortran::common
+
+#endif // LLVM_FLANG_COMMON_VERSION_H

flang/include/flang/Evaluate/target.h

public:
   bool IsTypeEnabled(common::TypeCategory category, std::int64_t kind) const;
 
   int SelectedIntKind(std::int64_t precision = 0) const;
   int SelectedRealKind(std::int64_t precision = 0, std::int64_t range = 0,
       std::int64_t radix = 2) const;
 
   static Rounding defaultRounding;
 
+  const std::string &compilerOptionsString() const {
+    return compilerOptionsString_;
+  };
+  TargetCharacteristics &set_compilerOptionsString(std::string x) {
+    compilerOptionsString_ = x;
+    return *this;
+  }
+
+  const std::string &compilerVersionString() const {
+    return compilerVersionString_;
+  };
+  TargetCharacteristics &set_compilerVersionString(std::string x) {
+    compilerVersionString_ = x;
+    return *this;
+  }
+
 private:
   static constexpr int maxKind{32};
   std::uint8_t byteSize_[common::TypeCategory_enumSize][maxKind]{};
   std::uint8_t align_[common::TypeCategory_enumSize][maxKind]{};
   bool isBigEndian_{false};
   bool areSubnormalsFlushedToZero_{false};
   Rounding roundingMode_{defaultRounding};
   std::size_t procedurePointerByteSize_{8};
   std::size_t procedurePointerAlignment_{8};
   std::size_t descriptorAlignment_{8};
   std::size_t maxByteSize_{8 /*at least*/};
   std::size_t maxAlignment_{8 /*at least*/};
+  std::string compilerOptionsString_;
+  std::string compilerVersionString_;
 };
 
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_TARGET_H_

flang/include/flang/Frontend/CompilerInvocation.h

class CompilerInvocation : public CompilerInvocationBase {
   Fortran::frontend::TargetOptions targetOpts;
 
   /// Options controlling IRgen and the backend.
   Fortran::frontend::CodeGenOptions codeGenOpts;
 
   /// Options controlling language dialect.
   Fortran::frontend::LangOptions langOpts;
 
+  // The string that will be set as the return value from the COMPILER_OPTIONS
+  // intrinsic of iso_fortran_env.
+  std::string compilerOptionsString;
+
   // Semantics context
   std::unique_ptr<Fortran::semantics::SemanticsContext> semanticsContext;
 
   /// Semantic options
   // TODO: Merge with or translate to frontendOpts. We shouldn't need two sets
   // of options.
   std::string moduleDir = ".";
 
public:
   }
 
   /// Create a compiler invocation from a list of input options.
   /// \returns true on success.
   /// \returns false if an error was encountered while parsing the arguments
   /// \param [out] res - The resulting invocation.
   static bool createFromArgs(CompilerInvocation &res,
                              llvm::ArrayRef<const char *> commandLineArgs,
-                             clang::DiagnosticsEngine &diags);
+                             clang::DiagnosticsEngine &diags,
+                             const char *argv0 = nullptr);
 
   // Enables the std=f2018 conformance check
   void setEnableConformanceChecks() { enableConformanceChecks = true; }
 
   /// Useful setters
   void setModuleDir(std::string &dir) { moduleDir = dir; }
 
   void setModuleFileSuffix(const char *suffix) {

flang/lib/Common/CMakeLists.txt

+find_first_existing_vc_file("${LLVM_MAIN_SRC_DIR}" llvm_vc)
+find_first_existing_vc_file("${FLANG_SOURCE_DIR}" flang_vc)
+
+# The VC revision include that we want to generate.
+set(version_inc "${CMAKE_CURRENT_BINARY_DIR}/VCSVersion.inc")
+
+set(generate_vcs_version_script "${LLVM_CMAKE_DIR}/GenerateVersionFromVCS.cmake")
+
+if(llvm_vc AND LLVM_APPEND_VC_REV)
+  set(llvm_source_dir ${LLVM_MAIN_SRC_DIR})
+endif()
+if(flang_vc AND LLVM_APPEND_VC_REV)
+  set(flang_source_dir ${FLANG_SOURCE_DIR})
+endif()
+
+# Create custom target to generate the VC revision include.
+add_custom_command(OUTPUT "${version_inc}"
+  DEPENDS "${llvm_vc}" "${flang_vc}" "${generate_vcs_version_script}"
+  COMMAND ${CMAKE_COMMAND} "-DNAMES=\"LLVM;FLANG\""
+                           "-DLLVM_SOURCE_DIR=${llvm_source_dir}"
+                           "-DFLANG_SOURCE_DIR=${flang_source_dir}"
+                           "-DHEADER_FILE=${version_inc}"
+                           -P "${generate_vcs_version_script}")
+
+# Mark the generated header as being generated.
+set_source_files_properties("${version_inc}"
+  PROPERTIES GENERATED TRUE
+             HEADER_FILE_ONLY TRUE)
+
+if(FLANG_VENDOR)
+  set_source_files_properties(Version.cpp
+    PROPERTIES COMPILE_DEFINITIONS "FLANG_VENDOR=\"${FLANG_VENDOR} \"")
+endif()
+
 
 add_flang_library(FortranCommon
   Fortran.cpp
   Fortran-features.cpp
   default-kinds.cpp
   idioms.cpp
+  Version.cpp
+  ${version_inc}
 
   LINK_COMPONENTS
   Support
 )

flang/lib/Common/Version.cpp

+//===- Version.cpp - Flang Version Number -------------------*- Fortran -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines several version-related utility functions for Flang.
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Common/Version.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cstdlib>
+#include <cstring>
+
+#include "VCSVersion.inc"
+
+namespace Fortran::common {
+
+std::string getFlangRepositoryPath() {
+#if defined(FLANG_REPOSITORY_STRING)
+  return FLANG_REPOSITORY_STRING;
+#else
+#ifdef FLANG_REPOSITORY
+  return FLANG_REPOSITORY;
+#else
+  return "";
+#endif
+#endif
+}
+
+std::string getLLVMRepositoryPath() {
+#ifdef LLVM_REPOSITORY
+  return LLVM_REPOSITORY;
+#else
+  return "";
+#endif
+}
+
+std::string getFlangRevision() {
+#ifdef FLANG_REVISION
+  return FLANG_REVISION;
+#else
+  return "";
+#endif
+}
+
+std::string getLLVMRevision() {
+#ifdef LLVM_REVISION
+  return LLVM_REVISION;
+#else
+  return "";
+#endif
+}
+
+std::string getFlangFullRepositoryVersion() {
+  std::string buf;
+  llvm::raw_string_ostream OS(buf);
+  std::string Path = getFlangRepositoryPath();
+  std::string Revision = getFlangRevision();
+  if (!Path.empty() || !Revision.empty()) {
+    OS << '(';
+    if (!Path.empty())
+      OS << Path;
+    if (!Revision.empty()) {
+      if (!Path.empty())
+        OS << ' ';
+      OS << Revision;
+    }
+    OS << ')';
+  }
+  // Support LLVM in a separate repository.
+  std::string LLVMRev = getLLVMRevision();
+  if (!LLVMRev.empty() && LLVMRev != Revision) {
+    OS << " (";
+    std::string LLVMRepo = getLLVMRepositoryPath();
+    if (!LLVMRepo.empty())
+      OS << LLVMRepo << ' ';
+    OS << LLVMRev << ')';
+  }
+  return buf;
+}
+
+std::string getFlangFullVersion() { return getFlangToolFullVersion("flang"); }
+
+std::string getFlangToolFullVersion(llvm::StringRef ToolName) {
+  std::string buf;
+  llvm::raw_string_ostream OS(buf);
+#ifdef FLANG_VENDOR
+  OS << FLANG_VENDOR;
+#endif
+  OS << ToolName << " version " FLANG_VERSION_STRING;
+
+  std::string repo = getFlangFullRepositoryVersion();
+  if (!repo.empty()) {
+    OS << " " << repo;
+  }
+
+  return buf;
+}
+
+} // end namespace Fortran::common

flang/lib/Evaluate/fold-character.cpp

if (auto scalars{GetScalarConstantArguments<T, SubscriptInteger>(
       }
     }
   } else if (name == "trim") { // not elemental
     if (auto scalar{
             GetScalarConstantArguments<T>(context, funcRef.arguments())}) {
       return Expr<T>{Constant<T>{
           CharacterUtils<KIND>::TRIM(std::get<Scalar<T>>(*scalar))}};
     }
+  } else if (name == "__builtin_compiler_options") {
+    auto &o = context.targetCharacteristics().compilerOptionsString();
+    return Expr<T>{Constant<T>{StringType(o.begin(), o.end())}};
+  } else if (name == "__builtin_compiler_version") {
+    auto &v = context.targetCharacteristics().compilerVersionString();
+    return Expr<T>{Constant<T>{StringType(v.begin(), v.end())}};
   }
   return Expr<T>{std::move(funcRef)};
 }
 
 template <int KIND>
 Expr<Type<TypeCategory::Character, KIND>> FoldOperation(
     FoldingContext &context, Concat<KIND> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {

flang/lib/Evaluate/intrinsics.cpp

// NULL() is a special case handled in Probe() below
         {{"x", AnyReal, Rank::elemental, Optionality::optional}},
         DefaultLogical},
     {"__builtin_ieee_support_subnormal",
         {{"x", AnyReal, Rank::elemental, Optionality::optional}},
         DefaultLogical},
     {"__builtin_ieee_support_underflow_control",
         {{"x", AnyReal, Rank::elemental, Optionality::optional}},
         DefaultLogical},
+    {"__builtin_compiler_options", {}, DefaultChar},
+    {"__builtin_compiler_version", {}, DefaultChar},
 };
 
 // TODO: Coarray intrinsic functions
 //  IMAGE_INDEX, COSHAPE
 // TODO: Non-standard intrinsic functions
 //  SHIFT,
 //  COMPL, EQV, NEQV, INT8, JINT, JNINT, KNINT,
 //  QCMPLX, QEXT, QFLOAT, QREAL, DNUM,
case KindCode::doublePrecision:
       resultType = DynamicType{*category, defaults.doublePrecisionKind()};
       break;
     case KindCode::defaultLogicalKind:
       CHECK(result.categorySet == LogicalType);
       CHECK(*category == TypeCategory::Logical);
       resultType = DynamicType{TypeCategory::Logical,
           defaults.GetDefaultKind(TypeCategory::Logical)};
       break;
+    case KindCode::defaultCharKind:
+      CHECK(result.categorySet == CharType);
+      CHECK(*category == TypeCategory::Character);
+      resultType = DynamicType{TypeCategory::Character,
+          defaults.GetDefaultKind(TypeCategory::Character)};
+      break;
     case KindCode::same:
       CHECK(sameArg);
       if (std::optional<DynamicType> aType{sameArg->GetType()}) {
         if (result.categorySet.test(aType->category())) {
           resultType = *aType;
         } else {
           resultType = DynamicType{*category, aType->kind()};
         }
if (auto category{result.categorySet.LeastElement()}) {
     case KindCode::teamType:
       CHECK(result.categorySet == DerivedType);
       CHECK(*category == TypeCategory::Derived);
       resultType = DynamicType{
           GetBuiltinDerivedType(builtinsScope, "__builtin_team_type")};
       break;
     case KindCode::exactKind:
       resultType = DynamicType{*category, result.exactKindValue};
       break;
-    case KindCode::defaultCharKind:
     case KindCode::typeless:
     case KindCode::any:
     case KindCode::kindArg:
     case KindCode::dimArg:
       common::die(
           "INTERNAL: bad KindCode appears on intrinsic '%s' result", name);
       break;
     default:
       CRASH_NO_CASE;

flang/lib/Frontend/CompilerInvocation.cpp

 //===- CompilerInvocation.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
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/CompilerInvocation.h"
 #include "flang/Common/Fortran-features.h"
+#include "flang/Common/Version.h"
 #include "flang/Frontend/CodeGenOptions.h"
 #include "flang/Frontend/PreprocessorOptions.h"
 #include "flang/Frontend/TargetOptions.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Version.inc"
 #include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/OptionUtils.h"
 #include "clang/Driver/Options.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Frontend/Debug/Options.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Host.h"
 #include "llvm/TargetParser/Triple.h"
+#include <cstdlib>
 #include <memory>
 #include <optional>
 
 using namespace Fortran::frontend;
 
 //===----------------------------------------------------------------------===//
 // Initialization.
 //===----------------------------------------------------------------------===//
if (args.getLastArg(clang::driver::options::OPT_ffast_math)) {
     opts.setFPContractMode(LangOptions::FPM_Fast);
   }
 
   return true;
 }
 
 bool CompilerInvocation::createFromArgs(
     CompilerInvocation &res, llvm::ArrayRef<const char *> commandLineArgs,
-    clang::DiagnosticsEngine &diags) {
+    clang::DiagnosticsEngine &diags, const char *argv0) {
 
   bool success = true;
 
   // Set the default triple for this CompilerInvocation. This might be
   // overridden by users with `-triple` (see the call to `ParseTargetArgs`
   // below).
   // NOTE: Like in Clang, it would be nice to use option marshalling
   // for this so that the entire logic for setting-up the triple is in one
bool CompilerInvocation::createFromArgs(
   res.frontendOpts.llvmArgs =
       args.getAllArgValues(clang::driver::options::OPT_mllvm);
 
   res.frontendOpts.mlirArgs =
       args.getAllArgValues(clang::driver::options::OPT_mmlir);
 
   success &= parseFloatingPointArgs(res, args, diags);
 
+  // Set the string to be used as the return value of the COMPILER_OPTIONS
+  // intrinsic of iso_fortran_env. This is either passed in from the parent
+  // compiler driver invocation with an environment variable, or failing that
+  // set to the command line arguments of the frontend driver invocation.
+  res.compilerOptionsString = std::string();
+  llvm::raw_string_ostream os(res.compilerOptionsString);
+  char *compilerOptsEnv = std::getenv("FLANG_COMPILER_OPTIONS_STRING");
+  if (compilerOptsEnv != nullptr) {
+    os << compilerOptsEnv;
+  } else {
+    os << argv0 << ' ';
+    for (auto it = commandLineArgs.begin(), e = commandLineArgs.end(); it != e;
+         ++it) {
+      os << ' ' << *it;
+    }
+  }
+
   return success;
 }
 
 void CompilerInvocation::collectMacroDefinitions() {
   auto &ppOpts = this->getPreprocessorOpts();
 
   for (unsigned i = 0, n = ppOpts.macros.size(); i != n; ++i) {
     llvm::StringRef macro = ppOpts.macros[i].first;
semanticsContext->set_moduleDirectory(getModuleDir())
       .set_moduleFileSuffix(getModuleFileSuffix());
 
   llvm::Triple targetTriple{llvm::Triple(this->targetOpts.triple)};
   // FIXME: Handle real(3) ?
   if (targetTriple.getArch() != llvm::Triple::ArchType::x86_64) {
     semanticsContext->targetCharacteristics().DisableType(
         Fortran::common::TypeCategory::Real, /*kind=*/10);
   }
+
+  std::string version = Fortran::common::getFlangFullVersion();
+  semanticsContext->targetCharacteristics()
+      .set_compilerOptionsString(compilerOptionsString)
+      .set_compilerVersionString(version);
 }
 
 /// Set \p loweringOptions controlling lowering behavior based
 /// on the \p optimizationLevel.
 void CompilerInvocation::setLoweringOptions() {
   const CodeGenOptions &codegenOpts = getCodeGenOpts();
 
   // Lower TRANSPOSE as a runtime call under -O0.
   loweringOpts.setOptimizeTranspose(codegenOpts.OptimizationLevel > 0);
 
   const LangOptions &langOptions = getLangOpts();

flang/module/__fortran_builtins.f90

module __Fortran_builtins
   type, private :: __force_derived_type_instantiations
     type(__builtin_c_ptr) :: c_ptr
     type(__builtin_c_funptr) :: c_funptr
     type(__builtin_event_type) :: event_type
     type(__builtin_lock_type) :: lock_type
     type(__builtin_team_type) :: team_type
   end type
 
+  intrinsic :: __builtin_compiler_options, __builtin_compiler_version
+
 end module

flang/module/iso_fortran_env.f90

 
 module iso_fortran_env
 
   use __Fortran_builtins, only: &
     event_type => __builtin_event_type, &
     lock_type => __builtin_lock_type, &
     team_type => __builtin_team_type, &
     atomic_int_kind => __builtin_atomic_int_kind, &
-    atomic_logical_kind => __builtin_atomic_logical_kind
+    atomic_logical_kind => __builtin_atomic_logical_kind, &
+    compiler_options => __builtin_compiler_options, &
+    compiler_version => __builtin_compiler_version
 
   implicit none
 
   ! TODO: Use PACK([x],test) in place of the array constructor idiom
   ! [(x, integer::j=1,COUNT([test]))] below once PACK() can be folded.
 
   integer, parameter, private :: &
     selectedASCII = selected_char_kind('ASCII'), &
module iso_fortran_env
 
   integer, parameter :: stat_failed_image = FORTRAN_RUNTIME_STAT_FAILED_IMAGE
   integer, parameter :: stat_locked = FORTRAN_RUNTIME_STAT_LOCKED
   integer, parameter :: stat_locked_other_image = FORTRAN_RUNTIME_STAT_LOCKED_OTHER_IMAGE
   integer, parameter :: stat_stopped_image = FORTRAN_RUNTIME_STAT_STOPPED_IMAGE
   integer, parameter :: stat_unlocked = FORTRAN_RUNTIME_STAT_UNLOCKED
   integer, parameter :: stat_unlocked_failed_image = FORTRAN_RUNTIME_STAT_UNLOCKED_FAILED_IMAGE
 
-  interface compiler_options
-    character(len=80) function compiler_options_1()
-    end function compiler_options_1
-  end interface compiler_options
-
-  interface compiler_version
-    character(len=80) function compiler_version_1()
-    end function compiler_version_1
-  end interface compiler_version
-
 end module iso_fortran_env

flang/test/Driver/compiler_options.f90

+! RUN: %flang -S -emit-llvm -o - %s | FileCheck %s
+! Test communication of COMPILER_OPTIONS from flang-new to flang-new -fc1.
+! CHECK: [[OPTSVAR:@_QQcl\.[0-9a-f]+]] = linkonce constant [[[OPTSLEN:[0-9]+]] x i8] c"{{.*}}flang-new{{(\.exe)?}} -S -emit-llvm -o - {{.*}}compiler_options.f90"
+program main
+    use ISO_FORTRAN_ENV, only: compiler_options
+    implicit none
+    character (len = :), allocatable :: v
+! CHECK: call void @llvm.memmove.p0.p0.i64(ptr %16, ptr [[OPTSVAR]], i64 [[OPTSLEN]], i1 false)
+    v = compiler_options()
+    print *, v
+    deallocate(v)
+    close(1)
+end program main

flang/test/Evaluate/compiler_options_fc1.f90

+! RUN: %flang_fc1 -fdebug-unparse %s 2>&1 | FileCheck %s
+
+program main
+    use ISO_FORTRAN_ENV, only: compiler_options
+    implicit none
+    character (len = :), allocatable :: v
+! CHECK: v="{{.*}}flang{{.*}} -fdebug-unparse {{.*}}"
+    v = compiler_options()
+    print *, v
+    deallocate(v)
+    close(1)
+end program main

flang/test/Evaluate/compiler_version.f90

+! RUN: %flang_fc1 -fdebug-unparse %s 2>&1 | FileCheck %s
+
+program main
+    use ISO_FORTRAN_ENV, only: compiler_version
+    implicit none
+    character (len = :), allocatable :: v
+! CHECK: v="flang version {{.*}}"
+    v = compiler_version()
+    print *, v
+    deallocate(v)
+    close(1)
+end program main

flang/tools/flang-driver/driver.cpp

 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/Compilation.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Host.h"
+#include <stdlib.h>
 
 using llvm::StringRef;
 
 // main frontend method. Lives inside fc1_main.cpp
 extern int fc1_main(llvm::ArrayRef<const char *> argv, const char *argv0);
 
 std::string getExecutablePath(const char *argv0) {
   // This just needs to be some symbol in the binary
clang::driver::Driver theDriver(driverPath,
                                   llvm::sys::getDefaultTargetTriple(), diags,
                                   "flang LLVM compiler");
   theDriver.setTargetAndMode(targetandMode);
   std::unique_ptr<clang::driver::Compilation> c(
       theDriver.BuildCompilation(args));
   llvm::SmallVector<std::pair<int, const clang::driver::Command *>, 4>
       failingCommands;
 
+  // Set the environment variable, FLANG_COMPILER_OPTIONS_STRING, to contain all
+  // the compiler options. This is intended for the frontend driver,
+  // flang-new -fc1, to enable the implementation of the COMPILER_OPTIONS
+  // intrinsic. To this end, the frontend driver requires the list of the
+  // original compiler options, which is not available through other means.
+  // TODO: This way of passing information between the compiler and frontend
+  // drivers is discouraged. We should find a better way not involving env
+  // variables.
+  std::string compilerOptsGathered;
+  llvm::raw_string_ostream os(compilerOptsGathered);
+  for (int i = 0; i < argc; ++i) {
+    os << argv[i];
+    if (i < argc - 1) {
+      os << ' ';
+    }
+  }
+#ifdef _WIN32
+  _putenv_s("FLANG_COMPILER_OPTIONS_STRING", compilerOptsGathered.c_str());
+#else
+  setenv("FLANG_COMPILER_OPTIONS_STRING", compilerOptsGathered.c_str(), 1);
+#endif
+
   // Run the driver
   int res = 1;
   bool isCrash = false;
   res = theDriver.ExecuteCompilation(*c, failingCommands);
 
   for (const auto &p : failingCommands) {
     int commandRes = p.first;
     const clang::driver::Command *failingCommand = p.second;

flang/tools/flang-driver/fc1_main.cpp

int fc1_main(llvm::ArrayRef<const char *> argv, const char *argv0) {
 
   // Create CompilerInvocation - use a dedicated instance of DiagnosticsEngine
   // for parsing the arguments
   llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> diagID(
       new clang::DiagnosticIDs());
   llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> diagOpts =
       new clang::DiagnosticOptions();
   clang::DiagnosticsEngine diags(diagID, &*diagOpts, diagsBuffer);
-  bool success =
-      CompilerInvocation::createFromArgs(flang->getInvocation(), argv, diags);
+  bool success = CompilerInvocation::createFromArgs(flang->getInvocation(),
+                                                    argv, diags, argv0);
 
   // Initialize targets first, so that --version shows registered targets.
   llvm::InitializeAllTargets();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmPrinters();
 
   diagsBuffer->flushDiagnostics(flang->getDiagnostics());