Port Classic Flang to LLVM 14

This is a combination of cherry-picking the following patches:

Commit 82b38d2:

    [ClassicFlang] Port release_90 changes from flang-compiler/llvm

    Cherry-picked commit 2085211cfcca70411dc63f0d08763facc8a02090 by Eric Schweitz,
    resolved merge conflicts, fixed build failures (e.g. adapted CGDebugInfo.cpp to
    the new API), and fixed the DIGlobalVariable unit tests, which have been broken
    since commit edfad65eebdf045b050f37380b6b61d673513982.

Commit 885dd87e5fdc:

    [DebugInfo] Removal of DIFortranArrayType and DIFortranSubrange

    These extensions are no more required after merge of below PR.

Commit 5c9b2e0867d5:

    Modification to incorporate comments from @bryanpkc.

Commit 822de2c:

    [AsmPrinter] Fix redundant names and types

    A bug was introduced in 82b38d2 while
    cherry-picking a DIGlobalVariable-related patch.

Commit 45a70a8:

    Port driver changes from release/11x

    Cherry-picked c51f89679135f84675f492d560ec5535c2000cfe by Varun Jayathirtha
    from release_90, and resolved merge conflicts.

    To avoid conflicts with the new Flang, lib/Driver/ToolChains/Flang.{cpp,h}
    have been renamed to ClassicFlang.{cpp,h}, and the ENABLE_CLASSIC_FLANG macro
    is introduced to select which incarnation of Flang to build. The macro is set
    by running CMake with -DLLVM_ENABLE_CLASSIC_FLANG.

    After merge with LLVM 11: Move flang options to the end of the definitions list.

Commit a9a8036:

    Port Classic Flang to LLVM 13

    File changes to TargetLibraryInfo and DebugLocEntry to adapt to the code from
    release/13.x and make it work. Comment out the changes due a segmentation
    fault, code need to be reviewed properly once all commits are in

Commit fe989b7:

    Fix -fveclib=PGMATH

    The use of #ifdef in include/clang/Driver/Options.td was incorrect and
    unsupported. As a result -fveclib=PGMATH was silently ignored, and
    in LLVM 12, it causes the invocation to fail. This patch unguards the
    option so that it is parsed correctly, but lets the FLANG_LLVM_EXTENSIONS
    macro continue to toggle the feature.

Commit 7c224ae:

    Fix use of classic Flang as preprocessor

Commit 8403c83:

    Merge FLANG_LLVM_EXTENSIONS macro into ENABLE_CLASSIC_FLANG

Commit 486741e:

    Fix test failures when in classic Flang mode

    Add a new lit feature tag "classic_flang" to select which tests can or cannot be
    run when the driver is built for classic Flang. Handle LLVM_ENABLE_CLASSIC_FLANG
    in llvm/cmake/modules/HandleLLVMOptions.cmake instead of clang/CMakeLists.txt so
    that macro works in both clang and llvm.

Commit a10f592:

    Port Classic Flang to LLVM 13

    LLVM port from release_12x to release_13x, changes done in order to
    make project able to be build.

Commit d385321 (partial):

    Change to Options.td in order to add the correct invocation for
    ffixed_line_length_VALUE.

clang/CMakeLists.txt

@@ -473,6 +473,11 @@ endif()
 
 add_definitions( -D_GNU_SOURCE )
 
+option(LLVM_ENABLE_CLASSIC_FLANG "Build support for classic Flang instead of the new built-in Flang" OFF)
+if(LLVM_ENABLE_CLASSIC_FLANG)
+  add_definitions( -DENABLE_CLASSIC_FLANG )
+endif()
+
 option(CLANG_BUILD_TOOLS
   "Build the Clang tools. If OFF, just generate build targets." ON)
 

clang/include/clang/Basic/CodeGenOptions.h

@@ -59,6 +59,7 @@ class CodeGenOptions : public CodeGenOptionsBase {
     Accelerate,        // Use the Accelerate framework.
     LIBMVEC,           // GLIBC vector math library.
     MASSV,             // IBM MASS vector library.
+    PGMATH,            // PGI math library.
     SVML,              // Intel short vector math library.
     Darwin_libsystem_m // Use Darwin's libsytem_m vector functions.
   };

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -122,6 +122,10 @@ def err_drv_invalid_linker_name : Error<
   "invalid linker name in argument '%0'">;
 def err_drv_invalid_rtlib_name : Error<
   "invalid runtime library name in argument '%0'">;
+def err_drv_invalid_allocatable_mode : Error<
+  "invalid semantic mode for assignments to allocatables in argument '%0'">;
+def err_drv_unsupported_fixed_line_length : Error<
+  "unsupported fixed-format line length in argument '%0'">;
 def err_drv_unsupported_rtlib_for_platform : Error<
   "unsupported runtime library '%0' for platform '%1'">;
 def err_drv_invalid_unwindlib_name : Error<
@@ -330,6 +334,8 @@ def err_drv_negative_columns : Error<
     "invalid value '%1' in '%0', value must be 'none' or a positive integer">;
 def err_drv_small_columns : Error<
     "invalid value '%1' in '%0', value must be '%2' or greater">;
+def err_drv_clang_unsupported_minfo_arg : Error<
+  "'%0' option does not support '%1' value">;
 
 def err_drv_invalid_malign_branch_EQ : Error<
   "invalid argument '%0' to -malign-branch=; each element must be one of: %1">;

clang/include/clang/Basic/MacroBuilder.h

@@ -24,9 +24,10 @@ class MacroBuilder {
   raw_ostream &Out;
 public:
   MacroBuilder(raw_ostream &Output) : Out(Output) {}
+  virtual ~MacroBuilder() {}
 
   /// Append a \#define line for macro of the form "\#define Name Value\n".
-  void defineMacro(const Twine &Name, const Twine &Value = "1") {
+  virtual void defineMacro(const Twine &Name, const Twine &Value = "1") {
     Out << "#define " << Name << ' ' << Value << '\n';
   }
 

clang/include/clang/Basic/Sanitizers.def

@@ -104,6 +104,8 @@ SANITIZER("signed-integer-overflow", SignedIntegerOverflow)
 SANITIZER("unreachable", Unreachable)
 SANITIZER("vla-bound", VLABound)
 SANITIZER("vptr", Vptr)
+// fortran contiguous pointer checks
+SANITIZER("discontiguous", Discontiguous)
 
 // IntegerSanitizer
 SANITIZER("unsigned-integer-overflow", UnsignedIntegerOverflow)

clang/include/clang/Driver/Action.h

@@ -62,6 +62,7 @@ class Action {
     AnalyzeJobClass,
     MigrateJobClass,
     CompileJobClass,
+    FortranFrontendJobClass,
     BackendJobClass,
     AssembleJobClass,
     LinkJobClass,
@@ -460,6 +461,16 @@ class MigrateJobAction : public JobAction {
   }
 };
 
+class FortranFrontendJobAction : public JobAction {
+  void anchor() override;
+public:
+  FortranFrontendJobAction(Action *Input, types::ID OutputType);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == FortranFrontendJobClass;
+  }
+};
+
 class CompileJobAction : public JobAction {
   void anchor() override;
 

clang/include/clang/Driver/Phases.h

@@ -17,6 +17,7 @@ namespace phases {
   enum ID {
     Preprocess,
     Precompile,
+    FortranFrontend,
     Compile,
     Backend,
     Assemble,

clang/include/clang/Driver/ToolChain.h

@@ -145,6 +145,7 @@ class ToolChain {
 
   mutable std::unique_ptr<Tool> Clang;
   mutable std::unique_ptr<Tool> Flang;
+  mutable std::unique_ptr<Tool> FortranFrontend;
   mutable std::unique_ptr<Tool> Assemble;
   mutable std::unique_ptr<Tool> Link;
   mutable std::unique_ptr<Tool> StaticLibTool;
@@ -155,6 +156,7 @@ class ToolChain {
 
   Tool *getClang() const;
   Tool *getFlang() const;
+  Tool *getFortranFrontend() const;
   Tool *getAssemble() const;
   Tool *getLink() const;
   Tool *getStaticLibTool() const;
@@ -601,6 +603,14 @@ class ToolChain {
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const;
 
+  /// \brief Add the flang arguments for system include paths.
+  ///
+  /// This routine is responsible for adding the -stdinc argument to
+  /// include headers and module files from standard system header directories.
+  virtual void
+  AddFlangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                            llvm::opt::ArgStringList &Flang1Args) const { }
+
   /// Add options that need to be passed to cc1 for this target.
   virtual void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                                      llvm::opt::ArgStringList &CC1Args,
@@ -693,6 +703,11 @@ class ToolChain {
   virtual llvm::SmallVector<BitCodeLibraryInfo, 12>
   getHIPDeviceLibs(const llvm::opt::ArgList &Args) const;
 
+  /// AddFortranStdlibLibArgs - Add the system specific linker arguments to use
+  /// for the given Fortran runtime library type.
+  virtual void AddFortranStdlibLibArgs(const llvm::opt::ArgList &Args,
+                                       llvm::opt::ArgStringList &CmdArgs) const;
+
   /// Return sanitizers which are available in this toolchain.
   virtual SanitizerMask getSupportedSanitizers() const;
 

clang/include/clang/Driver/Types.def

@@ -72,8 +72,15 @@ TYPE("c++-module-cpp-output",    PP_CXXModule, INVALID,         "iim",    phases
 TYPE("ada",                      Ada,          INVALID,         nullptr,  phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("assembler",                PP_Asm,       INVALID,         "s",      phases::Assemble, phases::Link)
 TYPE("assembler-with-cpp",       Asm,          PP_Asm,          "S",      phases::Preprocess, phases::Assemble, phases::Link)
+#ifdef ENABLE_CLASSIC_FLANG
+TYPE("f77",                      PP_F_FixedForm, INVALID,       "f",      phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link)
+TYPE("f77-cpp-input",            F_FixedForm,  PP_F_FixedForm,  "F",      phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link)
+TYPE("f95",                      PP_F_FreeForm, INVALID,        "f95",    phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link)
+TYPE("f95-cpp-input",            F_FreeForm,   PP_F_FreeForm,   "F95",    phases::FortranFrontend, phases::Backend, phases::Assemble, phases::Link)
+#else
 TYPE("f95",                      PP_Fortran,   INVALID,         nullptr,  phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("f95-cpp-input",            Fortran,      PP_Fortran,      nullptr,  phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link)
+#endif
 TYPE("java",                     Java,         INVALID,         nullptr,  phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 
 // LLVM IR/LTO types. We define separate types for IR and LTO because LTO

clang/include/clang/Driver/Types.h

@@ -95,6 +95,14 @@ namespace types {
   /// isFortran - Is this a Fortran input.
   bool isFortran(ID Id);
 
+#ifdef ENABLE_CLASSIC_FLANG
+  /// isFreeFormFortran -- is it a free form layout Fortran input
+  bool isFreeFormFortran(ID Id);
+
+  /// isFixedFormFortran -- is it a fixed form layout Fortran input
+  bool isFixedFormFortran(ID Id);
+#endif
+
   /// isSrcFile - Is this a source file, i.e. something that still has to be
   /// preprocessed. The logic behind this is the same that decides if the first
   /// compilation phase is a preprocessing one.

clang/include/clang/Frontend/Utils.h

@@ -17,6 +17,7 @@
 #include "clang/Basic/LLVM.h"
 #include "clang/Driver/OptionUtils.h"
 #include "clang/Frontend/DependencyOutputOptions.h"
+#include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/StringMap.h"
@@ -32,6 +33,12 @@
 #include <utility>
 #include <vector>
 
+namespace llvm {
+
+class StringRef;
+
+} // namespace llvm
+
 namespace clang {
 
 class ASTReader;
@@ -40,6 +47,7 @@ class CompilerInvocation;
 class DiagnosticsEngine;
 class ExternalSemaSource;
 class FrontendOptions;
+class MacroBuilder;
 class PCHContainerReader;
 class Preprocessor;
 class PreprocessorOptions;
@@ -55,6 +63,29 @@ void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts,
 void DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS,
                               const PreprocessorOutputOptions &Opts);
 
+/// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro
+/// named MacroName with the max value for a type with width 'TypeWidth' a
+/// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL).
+template<typename T>
+static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth,
+                           StringRef ValSuffix, bool isSigned,
+                           T &Builder) {
+  static_assert(std::is_base_of<MacroBuilder, T>::value, "Illegal T value");
+  llvm::APInt MaxVal = isSigned ? llvm::APInt::getSignedMaxValue(TypeWidth)
+                                : llvm::APInt::getMaxValue(TypeWidth);
+  Builder.defineMacro(MacroName, toString(MaxVal, 10, isSigned) + ValSuffix);
+}
+
+/// DefineTypeSize - An overloaded helper that uses TargetInfo to determine
+/// the width, suffix, and signedness of the given type
+template<typename T>
+static void DefineTypeSize(const Twine &MacroName, TargetInfo::IntType Ty,
+                           const TargetInfo &TI, T &Builder) {
+  static_assert(std::is_base_of<MacroBuilder, T>::value, "Illegal T value");
+  DefineTypeSize(MacroName, TI.getTypeWidth(Ty), TI.getTypeConstantSuffix(Ty),
+                 TI.isTypeSigned(Ty), Builder);
+}
+
 /// An interface for collecting the dependencies of a compilation. Users should
 /// use \c attachToPreprocessor and \c attachToASTReader to get all of the
 /// dependencies.

clang/lib/CodeGen/BackendUtil.cpp

@@ -437,6 +437,11 @@ static TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple,
     TLII->addVectorizableFunctionsFromVecLib(
         TargetLibraryInfoImpl::DarwinLibSystemM);
     break;
+#ifdef ENABLE_CLASSIC_FLANG
+  case CodeGenOptions::PGMATH:
+    TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::PGMATH);
+    break;
+#endif
   default:
     break;
   }

clang/lib/CodeGen/CGDebugInfo.cpp

@@ -3886,7 +3886,8 @@ CGDebugInfo::getGlobalVariableForwardDeclaration(const VarDecl *VD) {
   auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
   auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
       DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit),
-      !VD->isExternallyVisible(), nullptr, TemplateParameters, Align);
+      !VD->isExternallyVisible(), nullptr, TemplateParameters,
+      llvm::DINode::FlagZero, Align);
   FwdDeclReplaceMap.emplace_back(
       std::piecewise_construct,
       std::make_tuple(cast<VarDecl>(VD->getCanonicalDecl())),
@@ -5210,7 +5211,7 @@ void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
         getOrCreateType(T, Unit, TL), Var->hasLocalLinkage(), true,
         Expr.empty() ? nullptr : DBuilder.createExpression(Expr),
         getOrCreateStaticDataMemberDeclarationOrNull(D), TemplateParameters,
-        Align, Annotations);
+        llvm::DINode::FlagZero, Align, Annotations);
     Var->addDebugInfo(GVE);
   }
   DeclCache[D->getCanonicalDecl()].reset(GVE);
@@ -5298,7 +5299,7 @@ void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) {
   GV.reset(DBuilder.createGlobalVariableExpression(
       DContext, Name, StringRef(), Unit, getLineNumber(VD->getLocation()), Ty,
       true, true, InitExpr, getOrCreateStaticDataMemberDeclarationOrNull(VarD),
-      TemplateParameters, Align));
+      TemplateParameters, llvm::DINode::FlagZero, Align));
 }
 
 void CGDebugInfo::EmitExternalVariable(llvm::GlobalVariable *Var,
@@ -5316,7 +5317,8 @@ void CGDebugInfo::EmitExternalVariable(llvm::GlobalVariable *Var,
   llvm::DIGlobalVariableExpression *GVE =
       DBuilder.createGlobalVariableExpression(
           DContext, Name, StringRef(), Unit, getLineNumber(D->getLocation()),
-          Ty, false, false, nullptr, nullptr, nullptr, Align);
+          Ty, false, false, nullptr, nullptr, nullptr, llvm::DINode::FlagZero,
+          Align);
   Var->addDebugInfo(GVE);
 }
 

clang/lib/Driver/Action.cpp

@@ -28,6 +28,7 @@ const char *Action::getClassName(ActionClass AC) {
   case HeaderModulePrecompileJobClass: return "header-module-precompiler";
   case AnalyzeJobClass: return "analyzer";
   case MigrateJobClass: return "migrator";
+  case FortranFrontendJobClass: return "fortran-frontend";
   case CompileJobClass: return "compiler";
   case BackendJobClass: return "backend";
   case AssembleJobClass: return "assembler";
@@ -349,6 +350,12 @@ void MigrateJobAction::anchor() {}
 MigrateJobAction::MigrateJobAction(Action *Input, types::ID OutputType)
     : JobAction(MigrateJobClass, Input, OutputType) {}
 
+void FortranFrontendJobAction::anchor() {}
+
+FortranFrontendJobAction::FortranFrontendJobAction(Action *Input,
+                                             types::ID OutputType)
+    : JobAction(FortranFrontendJobClass, Input, OutputType) {}
+
 void CompileJobAction::anchor() {}
 
 CompileJobAction::CompileJobAction(Action *Input, types::ID OutputType)

clang/lib/Driver/CMakeLists.txt

@@ -11,6 +11,10 @@ if(WIN32)
   set(system_libs version)
 endif()
 
+if(LLVM_ENABLE_CLASSIC_FLANG)
+  set(CLASSIC_FLANG_FILES ToolChains/ClassicFlang.cpp)
+endif()
+
 add_clang_library(clangDriver
   Action.cpp
   Compilation.cpp
@@ -82,6 +86,7 @@ add_clang_library(clangDriver
   ToolChains/ZOS.cpp
   Types.cpp
   XRayArgs.cpp
+  ${CLASSIC_FLANG_FILES}
 
   DEPENDS
   ClangDriverOptions

clang/lib/Driver/Driver.cpp

@@ -327,19 +327,43 @@ phases::ID Driver::getFinalPhase(const DerivedArgList &DAL,
 
   // -{E,EP,P,M,MM} only run the preprocessor.
   if (CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
+#ifdef ENABLE_CLASSIC_FLANG
+      (PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
+#endif
       (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) ||
       (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) ||
       (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P)) ||
       CCGenDiagnostics) {
+#ifdef ENABLE_CLASSIC_FLANG
+    // -fsyntax-only or -E stops Fortran compilation after FortranFrontend
+    if (IsFlangMode() && (DAL.getLastArg(options::OPT_E) ||
+      DAL.getLastArg(options::OPT_fsyntax_only))) {
+      FinalPhase = phases::FortranFrontend;
+
+      // if not Fortran, fsyntax_only implies 'Compile' is the FinalPhase
+    } else if (DAL.getLastArg(options::OPT_fsyntax_only)) {
+      FinalPhase = phases::Compile;
+
+      // everything else has 'Preprocess' as its FinalPhase
+    } else {
+      FinalPhase = phases::Preprocess;
+    }
+#else
     FinalPhase = phases::Preprocess;
+#endif
 
   // --precompile only runs up to precompilation.
   } else if ((PhaseArg = DAL.getLastArg(options::OPT__precompile))) {
     FinalPhase = phases::Precompile;
 
+#ifdef ENABLE_CLASSIC_FLANG
+  // -{analyze,emit-ast} only run up to the compiler.
+  } else if ((PhaseArg = DAL.getLastArg(options::OPT_print_supported_cpus)) ||
+#else
   // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler.
   } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
              (PhaseArg = DAL.getLastArg(options::OPT_print_supported_cpus)) ||
+#endif
              (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) ||
              (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) ||
              (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
@@ -2322,7 +2346,11 @@ void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args,
         // stdin must be handled specially.
         if (memcmp(Value, "-", 2) == 0) {
           if (IsFlangMode()) {
+#ifdef ENABLE_CLASSIC_FLANG
+            Ty = types::TY_C;
+#else
             Ty = types::TY_Fortran;
+#endif
           } else {
             // If running with -E, treat as a C input (this changes the
             // builtin macros, for example). This may be overridden by -ObjC
@@ -3719,6 +3747,11 @@ void Driver::handleArguments(Compilation &C, DerivedArgList &Args,
       if (InputArg->isClaimed())
         continue;
 
+      // Fortran input is preprocessed using the frontend.
+      if (InitialPhase == phases::FortranFrontend &&
+          FinalPhase == phases::Preprocess)
+        continue;
+
       // Claim here to avoid the more general unused warning.
       InputArg->claim();
 
@@ -4175,6 +4208,13 @@ Action *Driver::ConstructPhaseAction(
                                                            ModName);
     return C.MakeAction<PrecompileJobAction>(Input, OutputTy);
   }
+  case phases::FortranFrontend: {
+    if (Args.hasArg(options::OPT_fsyntax_only))
+      return C.MakeAction<FortranFrontendJobAction>(Input,
+                                                    types::TY_Nothing);
+    return C.MakeAction<FortranFrontendJobAction>(Input,
+                                                  types::TY_LLVM_IR);
+  }
   case phases::Compile: {
     if (Args.hasArg(options::OPT_fsyntax_only))
       return C.MakeAction<CompileJobAction>(Input, types::TY_Nothing);